Introduce ty

Author: lukasbindreiter

.pre-commit-config.yaml

@@ -14,7 +14,12 @@ repos:
       - id: ruff-check
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
-  - repo: https://github.com/RobertCraigie/pyright-python
-    rev: v1.1.400
+  - repo: local
     hooks:
-      - id: pyright
+      - id: ty-check
+        name: ty-check
+        language: python
+        entry: ty check
+        pass_filenames: false
+        args: [--python=.venv/]
+        additional_dependencies: [ty]

pyproject.toml

@@ -24,11 +24,10 @@ dev = [
     "pyarrow>=17.0.0",
     # some dev tooling
     "ruff>=0.11.10",
-    # pyright 1.1.401 reports many wrong false positives, let's wait until that is fixed before upgrading
-    "pyright>=1.1.379,<1.1.401",
     "pre-commit>=3.8.0",
     "types-protobuf>=6.30",
     "junitparser>=3.2.0",
+    "ty>=0.0.11",
 ]
 
 [project.scripts]
@@ -112,33 +111,10 @@ known-first-party = ["tilebox", "_tilebox"]
 [tool.ruff.lint.per-file-ignores]
 "*/tests/*" = ["INP001", "SLF001"]
 
-[tool.pyright]
+[tool.ty.src]
 exclude = [
-    "**/.ipynb_checkpoints",
-    "**/__pycache__",
-    ".venv",
-    "tilebox-datasets/tests/example_dataset/*", # auto-generated code
-    "tilebox-workflows/tests/proto/*",          # auto-generated code
+    # auto-generated code
+    "**/*_pb2.py",
+    "**/*_pb2.pyi",
+    "**/*pb2_grpc.py"
 ]
-
-# ignore warnings in those files, but still type check them when used as a dependency in other files
-ignore = [
-    # it's auto generated
-    "**/datasets/v1",
-    "**/workflows/v1",
-    "**/tilebox/v1",
-    "**/buf/validate",
-]
-
-# pyright needs to have all the dependencies installed to be able to type check
-# we can make sure of this by telling it to use the uv venv
-venvPath = "."
-venv = ".venv"
-extraPaths = [
-    "tilebox-datasets",
-    "tilebox-grpc",
-    "tilebox-storage",
-    "tilebox-workflows",
-]
-
-reportPrivateImportUsage = false

tilebox-workflows/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+prek = "latest"

tilebox-workflows/tilebox/workflows/task.py

@@ -50,7 +50,7 @@ def __new__(cls, name: str, bases: tuple[type], attrs: dict[str, Any]) -> type:
             return task_class
 
         # Convert the class to a dataclass
-        task_class = dataclass(task_class)  # type: ignore[arg-type]
+        task_class = dataclass(task_class)
 
         # we allow overriding the execute method, but we still want to validate it
         # so we search for the closest base class that has an execute method and use
@@ -118,7 +118,7 @@ def _serialize(self) -> bytes:
 
     @classmethod
     def _deserialize(cls, task_input: bytes, context: RunnerContext | None = None) -> "Task":  # noqa: ARG003
-        return cast(Task, deserialize_task(cls, task_input))
+        return deserialize_task(cls, task_input)
 
 
 def _validate_execute_method(
@@ -201,7 +201,7 @@ def identifier() -> tuple[str, str]:
     class_name = task_class.__name__
     if hasattr(task_class, "identifier"):  # if the task class has an identifier method, we use that
         try:
-            name, version = task_class.identifier()
+            name, version = task_class.identifier()  # ty: ignore[call-non-callable]
         except TypeError as err:
             raise ValueError(
                 f"Failed to invoke {class_name}.identifier(). Is it a staticmethod or classmethod without parameters?"
@@ -422,7 +422,7 @@ def serialize_task(task: Task) -> bytes:
             field = json.dumps(field).encode()
         return field
 
-    return json.dumps(_serialize_as_dict(task)).encode()  # type: ignore[arg-type]
+    return json.dumps(_serialize_as_dict(task)).encode()
 
 
 def _serialize_as_dict(task: Task) -> dict[str, Any]:
@@ -452,7 +452,7 @@ def _serialize_value(value: Any, base64_encode_protobuf: bool) -> Any:  # noqa:
             return b64encode(value.SerializeToString()).decode("ascii")
         return value.SerializeToString()
     if is_dataclass(value):
-        return _serialize_as_dict(value)  # type: ignore[arg-type]
+        return _serialize_as_dict(value)
     return value
 
 
@@ -468,11 +468,11 @@ def deserialize_task(task_cls: type, task_input: bytes) -> Task:
         return task_cls()  # empty task
     if len(task_fields) == 1:
         # if there is only one field, we deserialize it directly
-        field_type = _get_deserialization_field_type(task_fields[0].type)  # type: ignore[arg-type]
+        field_type = _get_deserialization_field_type(task_fields[0].type)  # ty: ignore[invalid-argument-type]
         if hasattr(field_type, "FromString"):  # protobuf message
             value = field_type.FromString(task_input)  # type: ignore[arg-type]
         else:
-            value = _deserialize_value(field_type, json.loads(task_input.decode()))  # type: ignore[arg-type]
+            value = _deserialize_value(field_type, json.loads(task_input.decode()))
 
         return task_cls(**{task_fields[0].name: value})
 
@@ -483,7 +483,7 @@ def _deserialize_dataclass(cls: type, params: dict[str, Any]) -> Task:
     """Deserialize a dataclass, while allowing recursively nested dataclasses or protobuf messages."""
     for param in list(params):
         # recursively deserialize nested dataclasses
-        field = cls.__dataclass_fields__[param]
+        field = cls.__dataclass_fields__[param]  # ty: ignore[unresolved-attribute]
         params[field.name] = _deserialize_value(field.type, params[field.name])
 
     return cls(**params)
@@ -495,7 +495,7 @@ def _deserialize_value(field_type: type, value: Any) -> Any:  # noqa: PLR0911
 
     field_type = _get_deserialization_field_type(field_type)
     if hasattr(field_type, "FromString"):
-        return field_type.FromString(b64decode(value))
+        return field_type.FromString(b64decode(value))  # ty: ignore[call-non-callable]
     if is_dataclass(field_type) and isinstance(value, dict):
         return _deserialize_dataclass(field_type, value)