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

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(

hatchet_sdk/runnables/workflow.py

@@ -1,7 +1,8 @@
 import asyncio
+from collections.abc import Callable
 from datetime import datetime, timedelta, timezone
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast, get_type_hints
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, get_type_hints
 
 from google.protobuf import timestamp_pb2
 from pydantic import BaseModel, model_validator
@@ -11,6 +12,7 @@ from hatchet_sdk.clients.admin import (
     TriggerWorkflowOptions,
     WorkflowRunTriggerConfig,
 )
+from hatchet_sdk.clients.listeners.run_event_listener import RunEventListener
 from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
 from hatchet_sdk.clients.rest.models.v1_filter import V1Filter
 from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
@@ -371,7 +373,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         self,
         expression: str,
         scope: str,
-        payload: JSONSerializableMapping = {},
+        payload: JSONSerializableMapping | None = None,
     ) -> V1Filter:
         """
         Create a new filter.
@@ -393,7 +395,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         self,
         expression: str,
         scope: str,
-        payload: JSONSerializableMapping = {},
+        payload: JSONSerializableMapping | None = None,
     ) -> V1Filter:
         """
         Create a new filter.
@@ -458,7 +460,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         cron_name: str,
         expression: str,
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
-        additional_metadata: JSONSerializableMapping = {},
+        additional_metadata: JSONSerializableMapping | None = None,
         priority: int | None = None,
     ) -> CronWorkflows:
         """
@@ -477,7 +479,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
             cron_name=cron_name,
             expression=expression,
             input=self._serialize_input(input),
-            additional_metadata=additional_metadata,
+            additional_metadata=additional_metadata or {},
             priority=priority,
         )
 
@@ -486,7 +488,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         cron_name: str,
         expression: str,
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
-        additional_metadata: JSONSerializableMapping = {},
+        additional_metadata: JSONSerializableMapping | None = None,
         priority: int | None = None,
     ) -> CronWorkflows:
         """
@@ -505,7 +507,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
             cron_name=cron_name,
             expression=expression,
             input=self._serialize_input(input),
-            additional_metadata=additional_metadata,
+            additional_metadata=additional_metadata or {},
             priority=priority,
         )
 
@@ -620,7 +622,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
         Run the workflow asynchronously and wait for it to complete.
 
-        This method triggers a workflow run, blocks until completion, and returns the final result.
+        This method triggers a workflow run, awaits until completion, and returns the final result.
 
         :param input: The input data for the workflow, must match the workflow's input type.
         :param options: Additional options for workflow execution like metadata and parent workflow ID.
@@ -716,16 +718,16 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         name: str | None = None,
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
-        parents: list[Task[TWorkflowInput, Any]] = [],
+        parents: list[Task[TWorkflowInput, Any]] | None = None,
         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,
-        concurrency: list[ConcurrencyExpression] = [],
-        wait_for: list[Condition | OrGroup] = [],
-        skip_if: list[Condition | OrGroup] = [],
-        cancel_if: list[Condition | OrGroup] = [],
+        concurrency: list[ConcurrencyExpression] | None = None,
+        wait_for: list[Condition | OrGroup] | None = None,
+        skip_if: list[Condition | OrGroup] | None = None,
+        cancel_if: list[Condition | OrGroup] | None = None,
     ) -> Callable[
         [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
@@ -784,10 +786,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 schedule_timeout=computed_params.schedule_timeout,
                 parents=parents,
                 retries=computed_params.retries,
-                rate_limits=[r.to_proto() for r in rate_limits],
+                rate_limits=[r.to_proto() for r in rate_limits or []],
                 desired_worker_labels={
                     key: transform_desired_worker_label(d)
-                    for key, d in desired_worker_labels.items()
+                    for key, d in (desired_worker_labels or {}).items()
                 },
                 backoff_factor=computed_params.backoff_factor,
                 backoff_max_seconds=computed_params.backoff_max_seconds,
@@ -808,16 +810,16 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         name: str | None = None,
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
-        parents: list[Task[TWorkflowInput, Any]] = [],
+        parents: list[Task[TWorkflowInput, Any]] | None = None,
         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,
-        concurrency: list[ConcurrencyExpression] = [],
-        wait_for: list[Condition | OrGroup] = [],
-        skip_if: list[Condition | OrGroup] = [],
-        cancel_if: list[Condition | OrGroup] = [],
+        concurrency: list[ConcurrencyExpression] | None = None,
+        wait_for: list[Condition | OrGroup] | None = None,
+        skip_if: list[Condition | OrGroup] | None = None,
+        cancel_if: list[Condition | OrGroup] | None = None,
     ) -> Callable[
         [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
@@ -880,10 +882,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 schedule_timeout=computed_params.schedule_timeout,
                 parents=parents,
                 retries=computed_params.retries,
-                rate_limits=[r.to_proto() for r in rate_limits],
+                rate_limits=[r.to_proto() for r in rate_limits or []],
                 desired_worker_labels={
                     key: transform_desired_worker_label(d)
-                    for key, d in desired_worker_labels.items()
+                    for key, d in (desired_worker_labels or {}).items()
                 },
                 backoff_factor=computed_params.backoff_factor,
                 backoff_max_seconds=computed_params.backoff_max_seconds,
@@ -905,10 +907,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
+        rate_limits: list[RateLimit] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        concurrency: list[ConcurrencyExpression] = [],
+        concurrency: list[ConcurrencyExpression] | None = None,
     ) -> Callable[
         [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
@@ -947,10 +949,15 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 execution_timeout=execution_timeout,
                 schedule_timeout=schedule_timeout,
                 retries=retries,
-                rate_limits=[r.to_proto() for r in rate_limits],
+                rate_limits=[r.to_proto() for r in rate_limits or []],
                 backoff_factor=backoff_factor,
                 backoff_max_seconds=backoff_max_seconds,
                 concurrency=concurrency,
+                desired_worker_labels=None,
+                parents=None,
+                wait_for=None,
+                skip_if=None,
+                cancel_if=None,
             )
 
             if self._on_failure_task:
@@ -968,10 +975,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
-        rate_limits: list[RateLimit] = [],
+        rate_limits: list[RateLimit] | None = None,
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-        concurrency: list[ConcurrencyExpression] = [],
+        concurrency: list[ConcurrencyExpression] | None = None,
     ) -> Callable[
         [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
@@ -1010,11 +1017,15 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 execution_timeout=execution_timeout,
                 schedule_timeout=schedule_timeout,
                 retries=retries,
-                rate_limits=[r.to_proto() for r in rate_limits],
+                rate_limits=[r.to_proto() for r in rate_limits or []],
                 backoff_factor=backoff_factor,
                 backoff_max_seconds=backoff_max_seconds,
                 concurrency=concurrency,
-                parents=[],
+                parents=None,
+                desired_worker_labels=None,
+                wait_for=None,
+                skip_if=None,
+                cancel_if=None,
             )
 
             if self._on_success_task:
@@ -1087,6 +1098,9 @@ class TaskRunRef(Generic[TWorkflowInput, R]):
 
         return self._s._extract_result(result)
 
+    def stream(self) -> RunEventListener:
+        return self._wrr.stream()
+
 
 class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
     def __init__(
@@ -1123,13 +1137,14 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> R:
         """
-        Synchronously trigger a workflow run without waiting for it to complete.
-        This method is useful for starting a workflow run and immediately returning a reference to the run without blocking while the workflow runs.
+        Run the workflow synchronously and wait for it to complete.
+
+        This method triggers a workflow run, blocks until completion, and returns the extracted result.
 
         :param input: The input data for the workflow.
         :param options: Additional options for workflow execution.
 
-        :returns: A `WorkflowRunRef` object representing the reference to the workflow run.
+        :returns: The extracted result of the workflow execution.
         """
         return self._extract_result(self._workflow.run(input, options))
 
@@ -1141,12 +1156,12 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         """
         Run the workflow asynchronously and wait for it to complete.
 
-        This method triggers a workflow run, blocks until completion, and returns the final result.
+        This method triggers a workflow run, awaits until completion, and returns the extracted result.
 
         :param input: The input data for the workflow, must match the workflow's input type.
         :param options: Additional options for workflow execution like metadata and parent workflow ID.
 
-        :returns: The result of the workflow execution as a dictionary.
+        :returns: The extracted result of the workflow execution.
         """
         result = await self._workflow.aio_run(input, options)
         return self._extract_result(result)
@@ -1157,14 +1172,14 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> TaskRunRef[TWorkflowInput, R]:
         """
-        Run the workflow synchronously and wait for it to complete.
+        Trigger a workflow run without waiting for it to complete.
 
-        This method triggers a workflow run, blocks until completion, and returns the final result.
+        This method triggers a workflow run and immediately returns a reference to the run without blocking while the workflow runs.
 
         :param input: The input data for the workflow, must match the workflow's input type.
         :param options: Additional options for workflow execution like metadata and parent workflow ID.
 
-        :returns: The result of the workflow execution as a dictionary.
+        :returns: A `TaskRunRef` object representing the reference to the workflow run.
         """
         ref = self._workflow.run_no_wait(input, options)
 
@@ -1182,7 +1197,7 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         :param input: The input data for the workflow.
         :param options: Additional options for workflow execution.
 
-        :returns: A `WorkflowRunRef` object representing the reference to the workflow run.
+        :returns: A `TaskRunRef` object representing the reference to the workflow run.
         """
         ref = await self._workflow.aio_run_no_wait(input, options)
 

hatchet_sdk/utils/proto_enums.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Type, TypeVar, overload
+from typing import TypeVar, overload
 
 from google.protobuf.internal.enum_type_wrapper import EnumTypeWrapper
 
@@ -26,19 +26,19 @@ def convert_python_enum_to_proto(
 
 @overload
 def convert_proto_enum_to_python(
-    value: TProtoEnumValue, python_enum_class: Type[TPythonEnum], proto_enum: TProtoEnum
+    value: TProtoEnumValue, python_enum_class: type[TPythonEnum], proto_enum: TProtoEnum
 ) -> TPythonEnum: ...
 
 
 @overload
 def convert_proto_enum_to_python(
-    value: None, python_enum_class: Type[TPythonEnum], proto_enum: TProtoEnum
+    value: None, python_enum_class: type[TPythonEnum], proto_enum: TProtoEnum
 ) -> None: ...
 
 
 def convert_proto_enum_to_python(
     value: TProtoEnumValue | None,
-    python_enum_class: Type[TPythonEnum],
+    python_enum_class: type[TPythonEnum],
     proto_enum: TProtoEnum,
 ) -> TPythonEnum | None:
     if value is None:

hatchet_sdk/utils/timedelta_to_expression.py

@@ -18,7 +18,6 @@ def timedelta_to_expr(td: Duration) -> str:
     ## IMPORTANT: We only support hours, minutes, and seconds on the engine
     if seconds % HOUR == 0:
         return f"{seconds // HOUR}h"
-    elif seconds % MINUTE == 0:
+    if seconds % MINUTE == 0:
         return f"{seconds // MINUTE}m"
-    else:
-        return f"{seconds}s"
+    return f"{seconds}s"