tilebox-workflows 0.46.0__tar.gz → 0.48.0__tar.gz

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilebox-workflows
-Version: 0.46.0
+Version: 0.48.0
 Summary: Workflow client and task runner for Tilebox
 Project-URL: Homepage, https://tilebox.com
 Project-URL: Documentation, https://docs.tilebox.com/workflows/introduction

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/pyproject.toml

@@ -35,7 +35,13 @@ dependencies = [
 ]
 
 [dependency-groups]
-dev = ["hypothesis>=6.112.1", "pytest-cov>=5.0.0", "pytest>=8.3.2", "moto>=5"]
+dev = [
+    "hypothesis>=6.112.1",
+    "pytest-cov>=5.0.0",
+    "pytest>=8.3.2",
+    "moto>=5",
+    "pytest-asyncio>=1.3.0",
+]
 
 [project.urls]
 Homepage = "https://tilebox.com"

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/automations/cron.py

@@ -1,9 +1,8 @@
 from dataclasses import replace
 from datetime import datetime, timezone
-from typing import cast
 
 try:
-    from typing import Self
+    from typing import Self  # ty: ignore[unresolved-import]
 except ImportError:  # Self is only available in Python 3.11+
     from typing_extensions import Self
 
@@ -35,11 +34,11 @@ class CronTask(Task):
         return message.SerializeToString()
 
     @classmethod
-    def _deserialize(cls, task_input: bytes, context: RunnerContext | None = None) -> Self:  # noqa: ARG003
+    def _deserialize(cls: "type[CronTask]", task_input: bytes, context: RunnerContext | None = None) -> Self:  # noqa: ARG003
         message = AutomationMessage()
         message.ParseFromString(task_input)
 
-        task = cast(Self, deserialize_task(cls, message.args))
+        task = deserialize_task(cls, message.args)
 
         event_message = TriggeredCronEventMessage()
         event_message.ParseFromString(message.trigger_event)

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/automations/storage_event.py

@@ -1,9 +1,8 @@
 from dataclasses import replace
-from typing import cast
 from uuid import UUID
 
 try:
-    from typing import Self
+    from typing import Self  # ty: ignore[unresolved-import]
 except ImportError:  # Self is only available in Python 3.11+
     from typing_extensions import Self
 
@@ -43,11 +42,11 @@ class StorageEventTask(Task):
         return message.SerializeToString()
 
     @classmethod
-    def _deserialize(cls, task_input: bytes, context: RunnerContext | None = None) -> Self:
+    def _deserialize(cls: "type[StorageEventTask]", task_input: bytes, context: RunnerContext | None = None) -> Self:
         message = AutomationMessage()
         message.ParseFromString(task_input)
 
-        task = cast(cls, deserialize_task(cls, message.args))  # type: ignore[invalid-type-form]
+        task = deserialize_task(cls, message.args)
 
         event_message = TriggeredStorageEventMessage()
         event_message.ParseFromString(message.trigger_event)

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/cache.py

@@ -1,13 +1,16 @@
+import contextlib
 import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from io import BytesIO
 from pathlib import Path
+from pathlib import PurePosixPath as ObjectPath
 
 import boto3
 from botocore.exceptions import ClientError
 from google.cloud.exceptions import NotFound
 from google.cloud.storage import Blob, Bucket
+from obstore.store import ObjectStore
 
 
 class JobCache(ABC):
@@ -62,6 +65,53 @@ class NoCache(JobCache):
         return self
 
 
+class ObstoreCache(JobCache):
+    def __init__(self, store: ObjectStore, prefix: str | ObjectPath = ObjectPath(".")) -> None:
+        """A cache implementation backed by an obstore ObjectStore.
+
+        This cache implementation is the recommended way of working with the cache, as it provides a unified interface
+        for working with different object stores, while also providing a way to transparently work with local files
+        as well.
+
+        Args:
+            store: The object store to use for the cache.
+            prefix: A path prefix to append to all objects stored in the cache. Defaults to no prefix.
+        """
+        self.store = store
+        self.prefix = ObjectPath(prefix)
+
+    def __contains__(self, key: str) -> bool:
+        with contextlib.suppress(OSError):
+            self.store.get(str(self.prefix / key))
+            return True  # if get is successful, we know the key is in the cache
+
+        return False
+
+    def __setitem__(self, key: str, value: bytes) -> None:
+        self.store.put(str(self.prefix / key), value)
+
+    def __delitem__(self, key: str) -> None:
+        try:
+            self.store.delete(str(self.prefix / key))
+        except OSError:
+            raise KeyError(f"{key} is not cached!") from None
+
+    def __getitem__(self, key: str) -> bytes:
+        try:
+            entry = self.store.get(str(self.prefix / key))
+            return bytes(entry.bytes())
+        except OSError:
+            raise KeyError(f"{key} is not cached!") from None
+
+    def __iter__(self) -> Iterator[str]:
+        for obj in self.store.list_with_delimiter(str(self.prefix))["objects"]:
+            path: str = obj["path"]
+            yield path.removeprefix(str(self.prefix) + "/")
+
+    def group(self, key: str) -> "ObstoreCache":
+        return ObstoreCache(self.store, prefix=str(self.prefix / key))
+
+
 class InMemoryCache(JobCache):
     def __init__(self) -> None:
         """A simple in-memory cache implementation.
@@ -153,7 +203,7 @@ class LocalFileSystemCache(JobCache):
         Args:
             root: File system path where the cache will be stored. Defaults to "cache" in the current working directory.
         """
-        self.root = root if isinstance(root, Path) else Path(root)
+        self.root = Path(root)
 
     def __contains__(self, key: str) -> bool:
         return (self.root / key).exists()
@@ -184,7 +234,7 @@ class LocalFileSystemCache(JobCache):
 
 
 class GoogleStorageCache(JobCache):
-    def __init__(self, bucket: Bucket, prefix: str = "jobs") -> None:
+    def __init__(self, bucket: Bucket, prefix: str | ObjectPath = "jobs") -> None:
         """A cache implementation that stores data in Google Cloud Storage.
 
         Args:
@@ -192,23 +242,25 @@ class GoogleStorageCache(JobCache):
             prefix: A path prefix to append to all objects stored in the cache. Defaults to "jobs".
         """
         self.bucket = bucket
-        self.prefix = Path(prefix)  # we still use pathlib here, because it's easier to work with when joining paths
+        self.prefix = ObjectPath(
+            prefix
+        )  # we still use pathlib here, because it's easier to work with when joining paths
 
     def _blob(self, key: str) -> Blob:
         return self.bucket.blob(str(self.prefix / key))
 
     def __contains__(self, key: str) -> bool:
         # GCS library has some weird typing issues, so let's ignore them for now
-        return self._blob(key).exists()  # type: ignore[arg-type]
+        return self._blob(key).exists()
 
     def __setitem__(self, key: str, value: bytes) -> None:
         # GCS library has some weird typing issues, so let's ignore them for now
-        self._blob(key).upload_from_file(BytesIO(value))  # type: ignore[arg-type]
+        self._blob(key).upload_from_file(BytesIO(value))
 
     def __getitem__(self, key: str) -> bytes:
         try:
             # GCS library has some weird typing issues, so let's ignore them for now
-            return self._blob(key).download_as_bytes()  # type: ignore[arg-type]
+            return self._blob(key).download_as_bytes()
         except NotFound:
             raise KeyError(f"{key} is not cached!") from None
 
@@ -224,18 +276,18 @@ class GoogleStorageCache(JobCache):
         # in the "folder", and not the ones in subfolders
 
         # GCS library has some weird typing issues, so let's ignore them for now
-        blobs = self.bucket.list_blobs(prefix=prefix, delimiter="/")  # type: ignore[arg-type]
+        blobs = self.bucket.list_blobs(prefix=prefix, delimiter="/")
 
         # make the names relative to the cache prefix (but including the key in the name)
         for blob in blobs:
-            yield str(Path(blob.name).relative_to(self.prefix))
+            yield str(ObjectPath(blob.name).relative_to(self.prefix))
 
     def group(self, key: str) -> "GoogleStorageCache":
         return GoogleStorageCache(self.bucket, prefix=str(self.prefix / key))
 
 
 class AmazonS3Cache(JobCache):
-    def __init__(self, bucket: str, prefix: str = "jobs") -> None:
+    def __init__(self, bucket: str, prefix: str | ObjectPath = "jobs") -> None:
         """A cache implementation that stores data in Amazon S3.
 
         Args:
@@ -243,7 +295,7 @@ class AmazonS3Cache(JobCache):
             prefix: A path prefix to append to all objects stored in the cache. Defaults to "jobs".
         """
         self.bucket = bucket
-        self.prefix = Path(prefix)
+        self.prefix = ObjectPath(prefix)
         with warnings.catch_warnings():
             # https://github.com/boto/boto3/issues/3889
             warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*datetime.utcnow.*")

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/client.py

@@ -29,7 +29,7 @@ class Client:
             token: The API Key to authenticate with. If not set the `TILEBOX_API_KEY` environment variable will be used.
         """
         token = _token_from_env(url, token)
-        self._auth = {"token": token, "url": url}
+        self._auth: dict[str, str] = {"token": token, "url": url}
         self._channel = open_channel(url, token)
 
         self._tracer: WorkflowTracer | None = None

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/data.py

@@ -200,7 +200,7 @@ class JobState(Enum):
 _JOB_STATES = {state.value: state for state in JobState}
 
 # JobState.QUEUED is deprecated and has been renamed to SUBMITTED, but we keep it around for backwards compatibility
-JobState.QUEUED = JobState.SUBMITTED  # type: ignore[assignment]
+JobState.QUEUED = JobState.SUBMITTED  # ty: ignore[unresolved-attribute]
 
 
 @dataclass(order=True, frozen=True)
@@ -529,8 +529,8 @@ class StorageLocation:
                     span.set_attribute("bucket", self.location)
                     span.set_attribute("path", path)
                     # GCS library has some weird typing issues, so let's ignore them for now
-                    blob = runner_context.gcs_client(self.location).blob(path)  # type: ignore[arg-type]
-                    return blob.download_as_bytes()  # type: ignore[arg-type]
+                    blob = runner_context.gcs_client(self.location).blob(path)
+                    return blob.download_as_bytes()
             case StorageType.S3:
                 with runner_context.tracer.start_as_current_span("s3.read") as span:
                     span.set_attribute("bucket", self.location)

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/formatting/job.py

@@ -341,8 +341,7 @@ def _progress_indicator_bar(label: str, done: int, total: int, state: JobState)
         f"<span class='tbx-detail-mono'><span class='tbx-detail-value'>{percentage:.0%}</span> "
         f"<span class='tbx-detail-value-muted'>({done} / {total})</span></span>"
     )
-    label = HTML(label_html)
-    return HBox([progress, label])
+    return HBox([progress, HTML(label_html)])
 
 
 _eye_icon = """

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/jobs/client.py

@@ -19,7 +19,7 @@ from tilebox.workflows.task import FutureTask, merge_future_tasks_to_submissions
 from tilebox.workflows.task import Task as TaskInstance
 
 try:
-    from IPython.display import HTML, display  # type: ignore[assignment]
+    from IPython.display import HTML, display
 except ImportError:
 
     class HTML:
@@ -159,7 +159,7 @@ class JobClient:
 
     def query(
         self,
-        temporal_extent: TimeIntervalLike | IDIntervalLike,
+        temporal_extent: "TimeIntervalLike | IDIntervalLike",
         automation_ids: UUID | list[UUID] | None = None,
         job_states: JobState | list[JobState] | None = None,
         name: str | None = None,
@@ -192,11 +192,13 @@ class JobClient:
         id_interval: IDInterval | None = None
         match temporal_extent:
             case (str(), str()):
+                # ty doesn't narrow types on match statements yet, once it does we can remove this cast
+                str_temporal_extent: tuple[str, str] = temporal_extent  # ty: ignore[invalid-assignment]
                 # this is either a tuple of datetimes or a tuple of UUIDs
                 try:
-                    id_interval = IDInterval.parse(temporal_extent)
+                    id_interval = IDInterval.parse(str_temporal_extent)
                 except ValueError:
-                    dataset_time_interval = TimeInterval.parse(temporal_extent)
+                    dataset_time_interval = TimeInterval.parse(str_temporal_extent)
                     time_interval = TimeInterval(
                         start=dataset_time_interval.start,
                         end=dataset_time_interval.end,
@@ -206,7 +208,10 @@ class JobClient:
             case IDInterval(_, _, _, _) | (UUID(), UUID()):
                 id_interval = IDInterval.parse(temporal_extent)
             case _:
-                dataset_time_interval = TimeInterval.parse(temporal_extent)
+                # ty doesn't narrow types on match statements yet, once it does we can remove this cast
+                # because due to the match statement above we know that temporal_extent is a TimeIntervalLike
+                time_interval_like: TimeIntervalLike = temporal_extent  # ty: ignore[invalid-assignment]
+                dataset_time_interval = TimeInterval.parse(time_interval_like)
                 time_interval = TimeInterval(
                     start=dataset_time_interval.start,
                     end=dataset_time_interval.end,

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/observability/logging.py

@@ -110,7 +110,7 @@ def _otel_log_exporter(
         headers=headers,
     )
     schedule_delay = int(export_interval.total_seconds() * 1000) if export_interval is not None else None
-    return BatchLogRecordProcessor(exporter, schedule_delay_millis=schedule_delay)  # type: ignore[arg-type]
+    return BatchLogRecordProcessor(exporter, schedule_delay_millis=schedule_delay)
 
 
 def configure_otel_logging(
@@ -324,7 +324,7 @@ def get_logger(name: str | None = None, level: int = logging.NOTSET) -> logging.
         handler.setFormatter(ColorfulConsoleFormatter())
         # we set a special attribute, which allows as to remove this handler again as soon
         # as we configure an actual logging handler
-        handler._is_default = True  # type: ignore[attr-defined] # noqa: SLF001
+        handler._is_default = True  # ty: ignore[unresolved-attribute] # noqa: SLF001
         root_logger.addHandler(handler)
 
     logger = logging.getLogger(f"{_LOGGING_NAMESPACE}.{name}")

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/observability/tracing.py

@@ -116,7 +116,7 @@ def _otel_span_exporter(
         headers=headers,
     )
     schedule_delay = int(export_interval.total_seconds() * 1000) if export_interval is not None else None
-    return BatchSpanProcessor(exporter, schedule_delay_millis=schedule_delay)  # type: ignore[arg-type]
+    return BatchSpanProcessor(exporter, schedule_delay_millis=schedule_delay)
 
 
 class SpanEventLoggingHandler(logging.Handler):

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/runner/task_runner.py

@@ -19,6 +19,11 @@ from typing import Any, TypeAlias, TypeVar
 from uuid import UUID
 from warnings import warn
 
+try:
+    from typing import Self  # ty: ignore[unresolved-import]
+except ImportError:  # Self is only available in Python 3.11+
+    from typing_extensions import Self
+
 from loguru import logger
 from opentelemetry.trace.status import StatusCode
 from tenacity import retry, retry_if_exception_type, stop_when_event_set, wait_random_exponential
@@ -77,7 +82,7 @@ def _retry_backoff(func: Callable[..., WrappedFnReturnT], stop: stop_base) -> Ca
     Returns:
         The wrapped function
     """
-    return retry(  # type: ignore[no-any-return]
+    return retry(
         retry=retry_if_exception_type(InternalServerError),
         stop=stop,
         wait=wait_random_exponential(
@@ -159,8 +164,8 @@ class _LeaseRenewer(SpawnProcess):
         # we don't want to fork the current process, but instead spawn a new one
         # therefore we need to use the spawn context to create the queues
         ctx = get_context("spawn")
-        self._new_leases: Queue[tuple[UUID, TaskLease]] = ctx.Queue()  # type: ignore[assignment]
-        self._done_tasks: Queue[UUID] = ctx.Queue()  # type: ignore[assignment]
+        self._new_leases: Queue[tuple[UUID, TaskLease]] = ctx.Queue()
+        self._done_tasks: Queue[UUID] = ctx.Queue()
 
     def run(self) -> None:
         lease_renewer(self._url, self._token, self._new_leases, self._done_tasks)
@@ -260,7 +265,7 @@ class _GracefulShutdown:
         """Sleep for a given number of seconds, or until an interrupt signal is received."""
         self._interrupted.wait(seconds)
 
-    def __enter__(self) -> "_GracefulShutdown":
+    def __enter__(self) -> Self:
         """Enter a graceful shutdown context. Intercepts SIGTERM and SIGINT signals and delays them by a grace period."""
         self._original_sigterm = signal.signal(signal.SIGTERM, self._external_interrupt_handler)
         self._original_sigint = signal.signal(signal.SIGINT, self._external_interrupt_handler)
@@ -467,7 +472,7 @@ class TaskRunner:
                 span.update_name(f"task/{task_class.__name__}")
 
                 try:
-                    task_instance = task_class._deserialize(task.input, self._context)  # noqa: SLF001
+                    task_instance = task_class._deserialize(task.input, self._context)  # ty: ignore[possibly-missing-attribute] # noqa: SLF001
                 except json.JSONDecodeError:
                     self.logger.exception(f"Failed to deserialize input for task execution {task.id}")
                     raise ValueError(f"Failed to deserialize input for task execution {task.id}") from None
@@ -559,9 +564,9 @@ class ExecutionContext(ExecutionContextBase):
     def submit_subtasks(
         self,
         tasks: Sequence[TaskInstance],
+        depends_on: FutureTask | list[FutureTask] | None = None,
         cluster: str | None = None,
         max_retries: int = 0,
-        depends_on: FutureTask | list[FutureTask] | None = None,
     ) -> list[FutureTask]:
         return [
             self.submit_subtask(task, cluster=cluster, max_retries=max_retries, depends_on=depends_on) for task in tasks
@@ -575,7 +580,7 @@ class ExecutionContext(ExecutionContextBase):
             DeprecationWarning,
             stacklevel=2,
         )
-        return self.submit_subtasks(tasks, cluster, max_retries)
+        return self.submit_subtasks(tasks, cluster=cluster, max_retries=max_retries)
 
     def progress(self, label: str | None = None) -> ProgressUpdate:
         if label == "":

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/task.py

@@ -50,7 +50,7 @@ class _Taskify(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 @@ class Task(metaclass=_ABCTaskify):
 
     @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 _get_task_identifier(task_class: type) -> TaskIdentifier:
     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?"
@@ -356,7 +356,11 @@ class ExecutionContext(ABC):
 
     @abstractmethod
     def submit_subtask(
-        self, task: Task, depends_on: list[FutureTask] | None = None, cluster: str | None = None, max_retries: int = 0
+        self,
+        task: Task,
+        depends_on: FutureTask | list[FutureTask] | None = None,
+        cluster: str | None = None,
+        max_retries: int = 0,
     ) -> FutureTask:
         """Submit a subtask of the current task.
 
@@ -374,7 +378,11 @@ class ExecutionContext(ABC):
 
     @abstractmethod
     def submit_subtasks(
-        self, tasks: Sequence[Task], cluster: str | None = None, max_retries: int = 0
+        self,
+        tasks: Sequence[Task],
+        depends_on: FutureTask | list[FutureTask] | None = None,
+        cluster: str | None = None,
+        max_retries: int = 0,
     ) -> list[FutureTask]:
         """Submit a batch of subtasks of the current task. Similar to `submit_subtask`, but for multiple tasks."""
 
@@ -414,12 +422,12 @@ 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]:
     as_dict: dict[str, Any] = {}
-    for dataclass_field in fields(task):  # type: ignore[union-attr]
+    for dataclass_field in fields(task):  # ty: ignore[invalid-argument-type]
         skip = dataclass_field.metadata.get("skip_serialization", False)
         if skip:
             continue
@@ -444,11 +452,14 @@ 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
 
 
-def deserialize_task(task_cls: type, task_input: bytes) -> Task:
+_T = TypeVar("_T", bound=Task)
+
+
+def deserialize_task(task_cls: type[_T], task_input: bytes) -> _T:
     """Deserialize the input of a task from a buffer of bytes.
 
     The task_cls is expected to be a dataclass, containing an arbitrary number of fields.
@@ -460,22 +471,22 @@ 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]
+            value = field_type.FromString(task_input)  # ty: ignore[call-non-callable]
         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})
 
     return _deserialize_dataclass(task_cls, json.loads(task_input.decode()))
 
 
-def _deserialize_dataclass(cls: type, params: dict[str, Any]) -> Task:
+def _deserialize_dataclass(cls: type[_T], params: dict[str, Any]) -> _T:
     """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)
@@ -487,7 +498,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)
 

{tilebox_workflows-0.46.0 → tilebox_workflows-0.48.0}/tilebox/workflows/timeseries.py

@@ -26,11 +26,11 @@ def _timeseries_dataset_chunk(task: Task, call_next: ForwardExecution, context:
     if not isinstance(task, TimeseriesTask):
         raise TypeError("Task is not a timeseries task. Inherit from TimeseriesTask to mark it as such.")
 
-    chunk: TimeseriesDatasetChunk = task.timeseries_data  # type: ignore[attr-defined]
+    chunk: TimeseriesDatasetChunk = task.timeseries_data
 
     # let's get a collection client
     datasets_client = context.runner_context.datasets_client
-    dataset = datasets_client._dataset_by_id(str(chunk.dataset_id))  # type: ignore[attr-defined]  # noqa: SLF001
+    dataset = datasets_client._dataset_by_id(str(chunk.dataset_id))  # ty: ignore[possibly-missing-attribute]  # noqa: SLF001
     # we already know the collection id, so we can skip the lookup (we don't know the name, but don't need it)
     collection_info = CollectionInfo(Collection(chunk.collection_id, "unknown"), None, None)
     collection = CollectionClient(dataset, collection_info)
@@ -50,7 +50,7 @@ def _timeseries_dataset_chunk(task: Task, call_next: ForwardExecution, context:
 
         for i in range(datapoints.sizes["time"]):
             datapoint = datapoints.isel(time=i)
-            call_next(context, datapoint)  # type: ignore[call-arg]
+            call_next(context, datapoint)  # ty: ignore[too-many-positional-arguments]
 
         return  # we are done
 
@@ -90,7 +90,7 @@ def _timeseries_dataset_chunk(task: Task, call_next: ForwardExecution, context:
         for sub_chunk_start, sub_chunk_end in pairwise(chunks):
             sub_chunks.append(replace(chunk, time_interval=TimeInterval(sub_chunk_start, sub_chunk_end)))
 
-    subtasks = [replace(task, timeseries_data=sub_chunk) for sub_chunk in sub_chunks]  # type: ignore[misc]
+    subtasks = [replace(task, timeseries_data=sub_chunk) for sub_chunk in sub_chunks]
     if len(subtasks) > 0:
         context.submit_subtasks(subtasks)
 
@@ -103,7 +103,7 @@ class TimeseriesTask(Task):
     timeseries_data: TimeseriesDatasetChunk
 
     @override
-    def execute(self, context: ExecutionContext, datapoint: xr.Dataset) -> None:  # type: ignore[override]
+    def execute(self, context: ExecutionContext, datapoint: xr.Dataset) -> None:  # ty: ignore[invalid-method-override]
         pass
 
 
@@ -136,14 +136,14 @@ def _time_interval_chunk(task: Task, call_next: ForwardExecution, context: Execu
     if not isinstance(task, TimeIntervalTask):
         raise TypeError("Task is not a time interval task. Inherit from TimeIntervalTask to mark it as such.")
 
-    chunk: TimeChunk = task.interval  # type: ignore[attr-defined]
+    chunk: TimeChunk = task.interval
 
     start = _make_multiple(chunk.time_interval.start, chunk.chunk_size, before=True)
     end = _make_multiple(chunk.time_interval.end, chunk.chunk_size, before=False)
 
     n = (end - start) // chunk.chunk_size
     if n <= 1:  # we are already a leaf task
-        return call_next(context, TimeInterval(start, end))  # type: ignore[call-arg]
+        return call_next(context, TimeInterval(start, end))  # ty: ignore[too-many-positional-arguments]
 
     chunks: list[datetime] = []
     if n < 4:  # we are a branch task with less than 4 sub chunks, so a further split is not worth it
@@ -158,9 +158,7 @@ def _time_interval_chunk(task: Task, call_next: ForwardExecution, context: Execu
         TimeChunk(TimeInterval(chunk_start, chunk_end), chunk.chunk_size) for chunk_start, chunk_end in pairwise(chunks)
     ]
 
-    context.submit_subtasks(
-        [replace(task, interval=time_chunk) for time_chunk in time_chunks]  # type: ignore[misc]
-    )
+    context.submit_subtasks([replace(task, interval=time_chunk) for time_chunk in time_chunks])
     return None
 
 
@@ -170,12 +168,12 @@ class TimeIntervalTask(Task):
     interval: TimeChunk
 
     @override
-    def execute(self, context: ExecutionContext, time_interval: TimeInterval) -> None:  # type: ignore[override]
+    def execute(self, context: ExecutionContext, time_interval: TimeInterval) -> None:  # ty: ignore[invalid-method-override]
         pass
 
 
 def batch_process_time_interval(interval: TimeIntervalLike, chunk_size: timedelta) -> TimeChunk:
-    return TimeChunk(time_interval=TimeInterval.parse(interval).to_half_open(), chunk_size=chunk_size)  # type: ignore[arg-type]
+    return TimeChunk(time_interval=TimeInterval.parse(interval).to_half_open(), chunk_size=chunk_size)
 
 
 def _make_multiple(time: datetime, duration: timedelta, start: datetime = _EPOCH, before: bool = True) -> datetime: