hatchet-sdk 1.12.3__py3-none-any.whl → 1.14.0__py3-none-any.whl

hatchet_sdk/hatchet.py

@@ -1,8 +1,9 @@
 import asyncio
 import logging
+from collections.abc import Callable
 from datetime import timedelta
 from functools import cached_property
-from typing import Any, Callable, Type, Union, cast, overload
+from typing import Any, cast, overload
 
 from hatchet_sdk import Context, DurableContext
 from hatchet_sdk.client import Client
@@ -181,8 +182,8 @@ class Hatchet:
         name: str,
         slots: int = 100,
         durable_slots: int = 1_000,
-        labels: dict[str, Union[str, int]] = {},
-        workflows: list[BaseWorkflow[Any]] = [],
+        labels: dict[str, str | int] | None = None,
+        workflows: list[BaseWorkflow[Any]] | None = None,
         lifespan: LifespanFn | None = None,
     ) -> Worker:
         """
@@ -227,14 +228,14 @@ class Hatchet:
         name: str,
         description: str | None = None,
         input_validator: None = None,
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         task_defaults: TaskDefaults = TaskDefaults(),
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Workflow[EmptyModel]: ...
 
     @overload
@@ -243,15 +244,15 @@ class Hatchet:
         *,
         name: str,
         description: str | None = None,
-        input_validator: Type[TWorkflowInput],
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        input_validator: type[TWorkflowInput],
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         task_defaults: TaskDefaults = TaskDefaults(),
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Workflow[TWorkflowInput]: ...
 
     def workflow(
@@ -259,15 +260,15 @@ class Hatchet:
         *,
         name: str,
         description: str | None = None,
-        input_validator: Type[TWorkflowInput] | None = None,
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        input_validator: type[TWorkflowInput] | None = None,
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         task_defaults: TaskDefaults = TaskDefaults(),
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Workflow[EmptyModel] | Workflow[TWorkflowInput]:
         """
         Define a Hatchet workflow, which can then declare `task`s and be `run`, `schedule`d, and so on.
@@ -302,15 +303,15 @@ class Hatchet:
                 name=name,
                 version=version,
                 description=description,
-                on_events=on_events,
-                on_crons=on_crons,
+                on_events=on_events or [],
+                on_crons=on_crons or [],
                 sticky=sticky,
                 concurrency=concurrency,
                 input_validator=input_validator
-                or cast(Type[TWorkflowInput], EmptyModel),
+                or cast(type[TWorkflowInput], EmptyModel),
                 task_defaults=task_defaults,
                 default_priority=default_priority,
-                default_filters=default_filters,
+                default_filters=default_filters or [],
             ),
             self,
         )
@@ -322,8 +323,8 @@ class Hatchet:
         name: str | None = None,
         description: str | None = None,
         input_validator: None = None,
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
@@ -331,11 +332,11 @@ class Hatchet:
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
         [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
@@ -347,9 +348,9 @@ class Hatchet:
         *,
         name: str | None = None,
         description: str | None = None,
-        input_validator: Type[TWorkflowInput],
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        input_validator: type[TWorkflowInput],
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
@@ -357,11 +358,11 @@ class Hatchet:
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
         [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
         Standalone[TWorkflowInput, R],
@@ -372,9 +373,9 @@ class Hatchet:
         *,
         name: str | None = None,
         description: str | None = None,
-        input_validator: Type[TWorkflowInput] | None = None,
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        input_validator: type[TWorkflowInput] | None = None,
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
@@ -382,11 +383,11 @@ class Hatchet:
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> (
         Callable[
             [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
@@ -447,13 +448,13 @@ class Hatchet:
                     name=inferred_name,
                     version=version,
                     description=description,
-                    on_events=on_events,
-                    on_crons=on_crons,
+                    on_events=on_events or [],
+                    on_crons=on_crons or [],
                     sticky=sticky,
                     default_priority=default_priority,
                     input_validator=input_validator
-                    or cast(Type[TWorkflowInput], EmptyModel),
-                    default_filters=default_filters,
+                    or cast(type[TWorkflowInput], EmptyModel),
+                    default_filters=default_filters or [],
                 ),
                 self,
             )
@@ -471,8 +472,8 @@ class Hatchet:
                 execution_timeout=execution_timeout,
                 parents=[],
                 retries=retries,
-                rate_limits=rate_limits,
-                desired_worker_labels=desired_worker_labels,
+                rate_limits=rate_limits or [],
+                desired_worker_labels=desired_worker_labels or {},
                 backoff_factor=backoff_factor,
                 backoff_max_seconds=backoff_max_seconds,
                 concurrency=_concurrency,
@@ -494,8 +495,8 @@ class Hatchet:
         name: str | None = None,
         description: str | None = None,
         input_validator: None = None,
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
@@ -503,11 +504,11 @@ class Hatchet:
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
         [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
@@ -519,9 +520,9 @@ class Hatchet:
         *,
         name: str | None = None,
         description: str | None = None,
-        input_validator: Type[TWorkflowInput],
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        input_validator: type[TWorkflowInput],
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
@@ -529,11 +530,11 @@ class Hatchet:
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
         [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
         Standalone[TWorkflowInput, R],
@@ -544,9 +545,9 @@ class Hatchet:
         *,
         name: str | None = None,
         description: str | None = None,
-        input_validator: Type[TWorkflowInput] | None = None,
-        on_events: list[str] = [],
-        on_crons: list[str] = [],
+        input_validator: type[TWorkflowInput] | None = None,
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
@@ -554,11 +555,11 @@ class Hatchet:
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        default_filters: list[DefaultFilter] = [],
+        default_filters: list[DefaultFilter] | None = None,
     ) -> (
         Callable[
             [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
@@ -618,13 +619,13 @@ class Hatchet:
                     name=inferred_name,
                     version=version,
                     description=description,
-                    on_events=on_events,
-                    on_crons=on_crons,
+                    on_events=on_events or [],
+                    on_crons=on_crons or [],
                     sticky=sticky,
                     input_validator=input_validator
-                    or cast(Type[TWorkflowInput], EmptyModel),
+                    or cast(type[TWorkflowInput], EmptyModel),
                     default_priority=default_priority,
-                    default_filters=default_filters,
+                    default_filters=default_filters or [],
                 ),
                 self,
             )
@@ -642,8 +643,8 @@ class Hatchet:
                 execution_timeout=execution_timeout,
                 parents=[],
                 retries=retries,
-                rate_limits=rate_limits,
-                desired_worker_labels=desired_worker_labels,
+                rate_limits=rate_limits or [],
+                desired_worker_labels=desired_worker_labels or {},
                 backoff_factor=backoff_factor,
                 backoff_max_seconds=backoff_max_seconds,
                 concurrency=_concurrency,

hatchet_sdk/opentelemetry/instrumentor.py

@@ -1,6 +1,7 @@
 import json
+from collections.abc import Callable, Collection, Coroutine
 from importlib.metadata import version
-from typing import Any, Callable, Collection, Coroutine, Union, cast
+from typing import Any, cast
 
 from hatchet_sdk.contracts import workflows_pb2 as v0_workflow_protos
 from hatchet_sdk.utils.typing import JSONSerializableMapping
@@ -23,10 +24,10 @@ try:
         TraceContextTextMapPropagator,
     )
     from wrapt import wrap_function_wrapper  # type: ignore[import-untyped]
-except (RuntimeError, ImportError, ModuleNotFoundError):
+except (RuntimeError, ImportError, ModuleNotFoundError) as e:
     raise ModuleNotFoundError(
         "To use the HatchetInstrumentor, you must install Hatchet's `otel` extra using (e.g.) `pip install hatchet-sdk[otel]`"
-    )
+    ) from e
 
 import inspect
 from datetime import datetime
@@ -204,7 +205,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         super().__init__()
 
     def instrumentation_dependencies(self) -> Collection[str]:
-        return tuple()
+        return ()
 
     def _instrument(self, **kwargs: InstrumentKwargs) -> None:
         self._tracer = get_tracer(__name__, hatchet_sdk_version, self.tracer_provider)
@@ -394,11 +395,11 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             options = PushEventOptions(
                 **options.model_dump(exclude={"additional_metadata"}),
                 additional_metadata=_inject_traceparent_into_metadata(
-                    dict(options.additional_metadata),
+                    options.additional_metadata,
                 ),
             )
 
-            return wrapped(event_key, dict(payload), options)
+            return wrapped(event_key, payload, options)
 
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     def _wrap_bulk_push_event(
@@ -432,7 +433,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
                 BulkPushEventWithMetadata(
                     **event.model_dump(exclude={"additional_metadata"}),
                     additional_metadata=_inject_traceparent_into_metadata(
-                        dict(event.additional_metadata),
+                        event.additional_metadata,
                     ),
                 )
                 for event in bulk_events
@@ -494,7 +495,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             options = TriggerWorkflowOptions(
                 **options.model_dump(exclude={"additional_metadata"}),
                 additional_metadata=_inject_traceparent_into_metadata(
-                    dict(options.additional_metadata),
+                    options.additional_metadata,
                 ),
             )
 
@@ -551,19 +552,18 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             options = TriggerWorkflowOptions(
                 **options.model_dump(exclude={"additional_metadata"}),
                 additional_metadata=_inject_traceparent_into_metadata(
-                    dict(options.additional_metadata),
+                    options.additional_metadata,
                 ),
             )
 
             return await wrapped(workflow_name, payload, options)
 
-    def _ts_to_iso(self, ts: Union[datetime, timestamp_pb2.Timestamp]) -> str:
+    def _ts_to_iso(self, ts: datetime | timestamp_pb2.Timestamp) -> str:
         if isinstance(ts, datetime):
             return ts.isoformat()
-        elif isinstance(ts, timestamp_pb2.Timestamp):
+        if isinstance(ts, timestamp_pb2.Timestamp):
             return ts.ToJsonString()
-        else:
-            raise TypeError(f"Unsupported type for timestamp conversion: {type(ts)}")
+        raise TypeError(f"Unsupported type for timestamp conversion: {type(ts)}")
 
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     def _wrap_schedule_workflow(
@@ -571,7 +571,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         wrapped: Callable[
             [
                 str,
-                list[Union[datetime, timestamp_pb2.Timestamp]],
+                list[datetime | timestamp_pb2.Timestamp],
                 JSONSerializableMapping,
                 ScheduleTriggerWorkflowOptions,
             ],
@@ -580,14 +580,14 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         instance: AdminClient,
         args: tuple[
             str,
-            list[Union[datetime, timestamp_pb2.Timestamp]],
+            list[datetime | timestamp_pb2.Timestamp],
             JSONSerializableMapping,
             ScheduleTriggerWorkflowOptions,
         ],
         kwargs: dict[
             str,
             str
-            | list[Union[datetime, timestamp_pb2.Timestamp]]
+            | list[datetime | timestamp_pb2.Timestamp]
             | JSONSerializableMapping
             | ScheduleTriggerWorkflowOptions,
         ],
@@ -595,7 +595,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         params = self.extract_bound_args(wrapped, args, kwargs)
 
         workflow_name = cast(str, params[0])
-        schedules = cast(list[Union[datetime, timestamp_pb2.Timestamp]], params[1])
+        schedules = cast(list[datetime | timestamp_pb2.Timestamp], params[1])
         input = cast(JSONSerializableMapping, params[2])
         options = cast(
             ScheduleTriggerWorkflowOptions,
@@ -633,7 +633,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             options = ScheduleTriggerWorkflowOptions(
                 **options.model_dump(exclude={"additional_metadata"}),
                 additional_metadata=_inject_traceparent_into_metadata(
-                    dict(options.additional_metadata),
+                    options.additional_metadata,
                 ),
             )
 
@@ -673,7 +673,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
                     options=TriggerWorkflowOptions(
                         **config.options.model_dump(exclude={"additional_metadata"}),
                         additional_metadata=_inject_traceparent_into_metadata(
-                            dict(config.options.additional_metadata),
+                            config.options.additional_metadata,
                         ),
                     ),
                 )
@@ -705,7 +705,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
                     options=TriggerWorkflowOptions(
                         **config.options.model_dump(exclude={"additional_metadata"}),
                         additional_metadata=_inject_traceparent_into_metadata(
-                            dict(config.options.additional_metadata),
+                            config.options.additional_metadata,
                         ),
                     ),
                 )

hatchet_sdk/runnables/action.py

@@ -121,5 +121,4 @@ class Action(BaseModel):
         """
         if self.action_type == ActionType.START_GET_GROUP_KEY:
             return f"{self.get_group_key_run_id}/{self.retry_count}"
-        else:
-            return f"{self.step_run_id}/{self.retry_count}"
+        return f"{self.step_run_id}/{self.retry_count}"

hatchet_sdk/runnables/contextvars.py

@@ -1,4 +1,5 @@
 import asyncio
+import threading
 from collections import Counter
 from contextvars import ContextVar
 
@@ -15,3 +16,21 @@ ctx_worker_id: ContextVar[str | None] = ContextVar("ctx_worker_id", default=None
 
 workflow_spawn_indices = Counter[ActionKey]()
 spawn_index_lock = asyncio.Lock()
+
+
+class TaskCounter:
+    def __init__(self) -> None:
+        self._count = 0
+        self._lock = threading.Lock()
+
+    def increment(self) -> int:
+        with self._lock:
+            self._count += 1
+            return self._count
+
+    @property
+    def value(self) -> int:
+        return self._count
+
+
+task_count = TaskCounter()

hatchet_sdk/runnables/task.py

@@ -1,5 +1,5 @@
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast, get_type_hints
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Generic, cast, get_type_hints
 
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.contracts.v1.shared.condition_pb2 import TaskConditions
@@ -40,28 +40,30 @@ if TYPE_CHECKING:
 class Task(Generic[TWorkflowInput, R]):
     def __init__(
         self,
-        _fn: Union[
+        _fn: (
             Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]
-            | Callable[[TWorkflowInput, Context], AwaitableLike[R]],
-            Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]
-            | Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]],
-        ],
+            | Callable[[TWorkflowInput, Context], AwaitableLike[R]]
+            | (
+                Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]
+                | Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]]
+            )
+        ),
         is_durable: bool,
         type: StepType,
         workflow: "Workflow[TWorkflowInput]",
         name: str,
-        execution_timeout: Duration = timedelta(seconds=60),
-        schedule_timeout: Duration = timedelta(minutes=5),
-        parents: "list[Task[TWorkflowInput, Any]]" = [],
-        retries: int = 0,
-        rate_limits: list[CreateTaskRateLimit] = [],
-        desired_worker_labels: dict[str, DesiredWorkerLabels] = {},
-        backoff_factor: float | None = None,
-        backoff_max_seconds: int | None = None,
-        concurrency: list[ConcurrencyExpression] = [],
-        wait_for: list[Condition | OrGroup] = [],
-        skip_if: list[Condition | OrGroup] = [],
-        cancel_if: list[Condition | OrGroup] = [],
+        execution_timeout: Duration,
+        schedule_timeout: Duration,
+        parents: "list[Task[TWorkflowInput, Any]] | None",
+        retries: int,
+        rate_limits: list[CreateTaskRateLimit] | None,
+        desired_worker_labels: dict[str, DesiredWorkerLabels] | None,
+        backoff_factor: float | None,
+        backoff_max_seconds: int | None,
+        concurrency: list[ConcurrencyExpression] | None,
+        wait_for: list[Condition | OrGroup] | None,
+        skip_if: list[Condition | OrGroup] | None,
+        cancel_if: list[Condition | OrGroup] | None,
     ) -> None:
         self.is_durable = is_durable
 
@@ -74,17 +76,17 @@ class Task(Generic[TWorkflowInput, R]):
         self.execution_timeout = execution_timeout
         self.schedule_timeout = schedule_timeout
         self.name = name
-        self.parents = parents
+        self.parents = parents or []
         self.retries = retries
-        self.rate_limits = rate_limits
-        self.desired_worker_labels = desired_worker_labels
+        self.rate_limits = rate_limits or []
+        self.desired_worker_labels = desired_worker_labels or {}
         self.backoff_factor = backoff_factor
         self.backoff_max_seconds = backoff_max_seconds
-        self.concurrency = concurrency
+        self.concurrency = concurrency or []
 
-        self.wait_for = self._flatten_conditions(wait_for)
-        self.skip_if = self._flatten_conditions(skip_if)
-        self.cancel_if = self._flatten_conditions(cancel_if)
+        self.wait_for = self._flatten_conditions(wait_for or [])
+        self.skip_if = self._flatten_conditions(skip_if or [])
+        self.cancel_if = self._flatten_conditions(cancel_if or [])
 
         return_type = get_type_hints(_fn).get("return")
 
@@ -179,13 +181,19 @@ class Task(Generic[TWorkflowInput, R]):
             raise ValueError("Conditions must have unique readable data keys.")
 
         user_events = [
-            c.to_proto() for c in conditions if isinstance(c, UserEventCondition)
+            c.to_proto(self.workflow.client.config)
+            for c in conditions
+            if isinstance(c, UserEventCondition)
         ]
         parent_overrides = [
-            c.to_proto() for c in conditions if isinstance(c, ParentCondition)
+            c.to_proto(self.workflow.client.config)
+            for c in conditions
+            if isinstance(c, ParentCondition)
         ]
         sleep_conditions = [
-            c.to_proto() for c in conditions if isinstance(c, SleepCondition)
+            c.to_proto(self.workflow.client.config)
+            for c in conditions
+            if isinstance(c, SleepCondition)
         ]
 
         return TaskConditions(

hatchet_sdk/runnables/types.py

@@ -1,7 +1,8 @@
 import asyncio
 import json
+from collections.abc import Callable
 from enum import Enum
-from typing import Any, Callable, ParamSpec, Type, TypeGuard, TypeVar, Union
+from typing import Any, ParamSpec, TypeGuard, TypeVar
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -11,7 +12,7 @@ from hatchet_sdk.contracts.v1.workflows_pb2 import DefaultFilter as DefaultFilte
 from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import AwaitableLike, JSONSerializableMapping
 
-ValidTaskReturnType = Union[BaseModel, JSONSerializableMapping, None]
+ValidTaskReturnType = BaseModel | JSONSerializableMapping | None
 
 R = TypeVar("R", bound=ValidTaskReturnType)
 P = ParamSpec("P")
@@ -78,7 +79,7 @@ class DefaultFilter(BaseModel):
         return DefaultFilterProto(
             expression=self.expression,
             scope=self.scope,
-            payload=payload_json,
+            payload=payload_json.encode("utf-8"),
         )
 
 
@@ -92,7 +93,7 @@ class WorkflowConfig(BaseModel):
     on_crons: list[str] = Field(default_factory=list)
     sticky: StickyStrategy | None = None
     concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None
-    input_validator: Type[BaseModel] = EmptyModel
+    input_validator: type[BaseModel] = EmptyModel
     default_priority: int | None = None
 
     task_defaults: TaskDefaults = TaskDefaults()
@@ -107,7 +108,7 @@ class StepType(str, Enum):
 
 AsyncFunc = Callable[[TWorkflowInput, Context], AwaitableLike[R]]
 SyncFunc = Callable[[TWorkflowInput, Context], R]
-TaskFunc = Union[AsyncFunc[TWorkflowInput, R], SyncFunc[TWorkflowInput, R]]
+TaskFunc = AsyncFunc[TWorkflowInput, R] | SyncFunc[TWorkflowInput, R]
 
 
 def is_async_fn(
@@ -124,9 +125,9 @@ def is_sync_fn(
 
 DurableAsyncFunc = Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]]
 DurableSyncFunc = Callable[[TWorkflowInput, DurableContext], R]
-DurableTaskFunc = Union[
-    DurableAsyncFunc[TWorkflowInput, R], DurableSyncFunc[TWorkflowInput, R]
-]
+DurableTaskFunc = (
+    DurableAsyncFunc[TWorkflowInput, R] | DurableSyncFunc[TWorkflowInput, R]
+)
 
 
 def is_durable_async_fn(