hatchet-sdk 0.42.3__py3-none-any.whl → 0.42.4__py3-none-any.whl

hatchet_sdk/clients/admin.py

@@ -41,7 +41,7 @@ def new_admin(config: ClientConfig):
     return AdminClient(config)
 
 
-class ScheduleTriggerWorkflowOptions(TypedDict):
+class ScheduleTriggerWorkflowOptions(TypedDict, total=False):
     parent_id: Optional[str]
     parent_step_run_id: Optional[str]
     child_index: Optional[int]
@@ -49,25 +49,25 @@ class ScheduleTriggerWorkflowOptions(TypedDict):
     namespace: Optional[str]
 
 
-class ChildTriggerWorkflowOptions(TypedDict):
+class ChildTriggerWorkflowOptions(TypedDict, total=False):
     additional_metadata: Dict[str, str] | None = None
     sticky: bool | None = None
 
 
-class ChildWorkflowRunDict(TypedDict):
+class ChildWorkflowRunDict(TypedDict, total=False):
     workflow_name: str
     input: Any
     options: ChildTriggerWorkflowOptions
     key: str | None = None
 
 
-class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions, TypedDict):
+class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions, total=False):
     additional_metadata: Dict[str, str] | None = None
     desired_worker_id: str | None = None
     namespace: str | None = None
 
 
-class WorkflowRunDict(TypedDict):
+class WorkflowRunDict(TypedDict, total=False):
     workflow_name: str
     input: Any
     options: TriggerWorkflowOptions | None
@@ -425,7 +425,7 @@ class AdminClient(AdminClientBase):
         self,
         key: str,
         limit: int,
-        duration: RateLimitDuration = RateLimitDuration.SECOND,
+        duration: Union[RateLimitDuration.Value, str] = RateLimitDuration.SECOND,
     ):
         try:
             self.client.PutRateLimit(

hatchet_sdk/clients/dispatcher/dispatcher.py

@@ -1,3 +1,5 @@
+from typing import Any, cast
+
 from google.protobuf.timestamp_pb2 import Timestamp
 
 from hatchet_sdk.clients.dispatcher.action_listener import (
@@ -31,7 +33,7 @@ from ...metadata import get_metadata
 DEFAULT_REGISTER_TIMEOUT = 30
 
 
-def new_dispatcher(config: ClientConfig):
+def new_dispatcher(config: ClientConfig) -> "DispatcherClient":
     return DispatcherClient(config=config)
 
 
@@ -40,10 +42,10 @@ class DispatcherClient:
 
     def __init__(self, config: ClientConfig):
         conn = new_conn(config)
-        self.client = DispatcherStub(conn)
+        self.client = DispatcherStub(conn)  # type: ignore[no-untyped-call]
 
         aio_conn = new_conn(config, True)
-        self.aio_client = DispatcherStub(aio_conn)
+        self.aio_client = DispatcherStub(aio_conn)  # type: ignore[no-untyped-call]
         self.token = config.token
         self.config = config
 
@@ -67,7 +69,7 @@ class DispatcherClient:
 
     async def send_step_action_event(
         self, action: Action, event_type: StepActionEventType, payload: str
-    ):
+    ) -> Any:
         try:
             return await self._try_send_step_action_event(action, event_type, payload)
         except Exception as e:
@@ -87,7 +89,7 @@ class DispatcherClient:
     @tenacity_retry
     async def _try_send_step_action_event(
         self, action: Action, event_type: StepActionEventType, payload: str
-    ):
+    ) -> Any:
         eventTimestamp = Timestamp()
         eventTimestamp.GetCurrentTime()
 
@@ -103,6 +105,7 @@ class DispatcherClient:
             eventPayload=payload,
         )
 
+        ## TODO: What does this return?
         return await self.aio_client.SendStepActionEvent(
             event,
             metadata=get_metadata(self.token),
@@ -110,7 +113,7 @@ class DispatcherClient:
 
     async def send_group_key_action_event(
         self, action: Action, event_type: GroupKeyActionEventType, payload: str
-    ):
+    ) -> Any:
         eventTimestamp = Timestamp()
         eventTimestamp.GetCurrentTime()
 
@@ -124,19 +127,21 @@ class DispatcherClient:
             eventPayload=payload,
         )
 
+        ## TODO: What does this return?
         return await self.aio_client.SendGroupKeyActionEvent(
             event,
             metadata=get_metadata(self.token),
         )
 
-    def put_overrides_data(self, data: OverridesData):
-        response: ActionEventResponse = self.client.PutOverridesData(
-            data,
-            metadata=get_metadata(self.token),
+    def put_overrides_data(self, data: OverridesData) -> ActionEventResponse:
+        return cast(
+            ActionEventResponse,
+            self.client.PutOverridesData(
+                data,
+                metadata=get_metadata(self.token),
+            ),
         )
 
-        return response
-
     def release_slot(self, step_run_id: str) -> None:
         self.client.ReleaseSlot(
             ReleaseSlotRequest(stepRunId=step_run_id),
@@ -154,7 +159,9 @@ class DispatcherClient:
             metadata=get_metadata(self.token),
         )
 
-    def upsert_worker_labels(self, worker_id: str, labels: dict[str, str | int]):
+    def upsert_worker_labels(
+        self, worker_id: str | None, labels: dict[str, str | int]
+    ) -> None:
         worker_labels = {}
 
         for key, value in labels.items():
@@ -171,9 +178,9 @@ class DispatcherClient:
 
     async def async_upsert_worker_labels(
         self,
-        worker_id: str,
+        worker_id: str | None,
         labels: dict[str, str | int],
-    ):
+    ) -> None:
         worker_labels = {}
 
         for key, value in labels.items():

hatchet_sdk/clients/events.py

@@ -43,16 +43,16 @@ def proto_timestamp_now():
     return timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
 
 
-class PushEventOptions(TypedDict):
+class PushEventOptions(TypedDict, total=False):
     additional_metadata: Dict[str, str] | None = None
     namespace: str | None = None
 
 
-class BulkPushEventOptions(TypedDict):
+class BulkPushEventOptions(TypedDict, total=False):
     namespace: str | None = None
 
 
-class BulkPushEventWithMetadata(TypedDict):
+class BulkPushEventWithMetadata(TypedDict, total=False):
     key: str
     payload: Any
     additional_metadata: Optional[Dict[str, Any]]  # Optional metadata

hatchet_sdk/clients/rest/models/workflow_list.py

@@ -32,10 +32,10 @@ class WorkflowList(BaseModel):
     WorkflowList
     """  # noqa: E501
 
-    metadata: Optional[APIResourceMeta] = None
-    rows: Optional[List[Workflow]] = None
-    pagination: Optional[PaginationResponse] = None
-    __properties: ClassVar[List[str]] = ["metadata", "rows", "pagination"]
+    metadata: APIResourceMeta | None = None
+    rows: list[Workflow] | None = None
+    pagination: PaginationResponse | None = None
+    __properties: ClassVar[list[str]] = ["metadata", "rows", "pagination"]
 
     model_config = ConfigDict(
         populate_by_name=True,

hatchet_sdk/clients/rest/models/workflow_run.py

@@ -39,28 +39,28 @@ class WorkflowRun(BaseModel):
     metadata: APIResourceMeta
     tenant_id: StrictStr = Field(alias="tenantId")
     workflow_version_id: StrictStr = Field(alias="workflowVersionId")
-    workflow_version: Optional[WorkflowVersion] = Field(
+    workflow_version: WorkflowVersion | None = Field(
         default=None, alias="workflowVersion"
     )
     status: WorkflowRunStatus
-    display_name: Optional[StrictStr] = Field(default=None, alias="displayName")
-    job_runs: Optional[List[JobRun]] = Field(default=None, alias="jobRuns")
+    display_name: StrictStr | None = Field(default=None, alias="displayName")
+    job_runs: list[JobRun] | None = Field(default=None, alias="jobRuns")
     triggered_by: WorkflowRunTriggeredBy = Field(alias="triggeredBy")
-    input: Optional[Dict[str, Any]] = None
-    error: Optional[StrictStr] = None
-    started_at: Optional[datetime] = Field(default=None, alias="startedAt")
-    finished_at: Optional[datetime] = Field(default=None, alias="finishedAt")
-    duration: Optional[StrictInt] = None
+    input: dict[str, Any] | None = None
+    error: StrictStr | None = None
+    started_at: datetime | None = Field(default=None, alias="startedAt")
+    finished_at: datetime | None = Field(default=None, alias="finishedAt")
+    duration: StrictInt | None = None
     parent_id: Optional[
         Annotated[str, Field(min_length=36, strict=True, max_length=36)]
     ] = Field(default=None, alias="parentId")
     parent_step_run_id: Optional[
         Annotated[str, Field(min_length=36, strict=True, max_length=36)]
     ] = Field(default=None, alias="parentStepRunId")
-    additional_metadata: Optional[Dict[str, Any]] = Field(
+    additional_metadata: dict[str, Any] | None = Field(
         default=None, alias="additionalMetadata"
     )
-    __properties: ClassVar[List[str]] = [
+    __properties: ClassVar[list[str]] = [
         "metadata",
         "tenantId",
         "workflowVersionId",

hatchet_sdk/context/context.py

@@ -13,8 +13,8 @@ from hatchet_sdk.clients.rest_client import RestApi
 from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.context.worker_context import WorkerContext
-from hatchet_sdk.contracts.dispatcher_pb2 import OverridesData  # type: ignore
-from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
+from hatchet_sdk.contracts.dispatcher_pb2 import OverridesData
+from hatchet_sdk.contracts.workflows_pb2 import (
     BulkTriggerWorkflowRequest,
     TriggerWorkflowRequest,
 )
@@ -69,7 +69,7 @@ class BaseContext:
             meta = options["additional_metadata"]
 
         ## TODO: Pydantic here to simplify this
-        trigger_options: TriggerWorkflowOptions = {  # type: ignore[typeddict-item]
+        trigger_options: TriggerWorkflowOptions = {
             "parent_id": workflow_run_id,
             "parent_step_run_id": step_run_id,
             "child_key": key,
@@ -149,8 +149,7 @@ class ContextAioImpl(BaseContext):
             key = child_workflow_run.get("key")
             options = child_workflow_run.get("options", {})
 
-            ## TODO: figure out why this is failing
-            trigger_options = self._prepare_workflow_options(key, options, worker_id)  # type: ignore[arg-type]
+            trigger_options = self._prepare_workflow_options(key, options, worker_id)
 
             bulk_trigger_workflow_runs.append(
                 WorkflowRunDict(
@@ -238,14 +237,17 @@ class Context(BaseContext):
             self.input = self.data.get("input", {})
 
     def step_output(self, step: str) -> dict[str, Any] | BaseModel:
-        validators = self.validator_registry.get(step)
+        workflow_validator = next(
+            (v for k, v in self.validator_registry.items() if k.split(":")[-1] == step),
+            None,
+        )
 
         try:
             parent_step_data = cast(dict[str, Any], self.data["parents"][step])
         except KeyError:
             raise ValueError(f"Step output for '{step}' not found")
 
-        if validators and (v := validators.step_output):
+        if workflow_validator and (v := workflow_validator.step_output):
             return v.model_validate(parent_step_data)
 
         return parent_step_data

hatchet_sdk/context/worker_context.py

@@ -2,7 +2,7 @@ from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
 
 
 class WorkerContext:
-    _worker_id: str = None
+    _worker_id: str | None = None
     _registered_workflow_names: list[str] = []
     _labels: dict[str, str | int] = {}
 
@@ -10,18 +10,18 @@ class WorkerContext:
         self._labels = labels
         self.client = client
 
-    def labels(self):
+    def labels(self) -> dict[str, str | int]:
         return self._labels
 
-    def upsert_labels(self, labels: dict[str, str | int]):
+    def upsert_labels(self, labels: dict[str, str | int]) -> None:
         self.client.upsert_worker_labels(self._worker_id, labels)
         self._labels.update(labels)
 
-    async def async_upsert_labels(self, labels: dict[str, str | int]):
+    async def async_upsert_labels(self, labels: dict[str, str | int]) -> None:
         await self.client.async_upsert_worker_labels(self._worker_id, labels)
         self._labels.update(labels)
 
-    def id(self) -> str:
+    def id(self) -> str | None:
         return self._worker_id
 
     # def has_workflow(self, workflow_name: str):

hatchet_sdk/hatchet.py

@@ -1,15 +1,13 @@
 import asyncio
 import logging
-from typing import Any, Callable, Optional, Type, TypeVar, cast, get_type_hints
+from typing import Any, Callable, Optional, Type, TypeVar, Union
 
 from pydantic import BaseModel
 from typing_extensions import deprecated
 
 from hatchet_sdk.clients.rest_client import RestApi
-
-## TODO: These type stubs need to be updated to mass MyPy, and then we can remove this ignore
-## There are file-level type ignore lines in the corresponding .pyi files.
-from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
+from hatchet_sdk.context.context import Context
+from hatchet_sdk.contracts.workflows_pb2 import (
     ConcurrencyLimitStrategy,
     CreateStepRateLimit,
     DesiredWorkerLabels,
@@ -20,6 +18,7 @@ from hatchet_sdk.features.scheduled import ScheduledClient
 from hatchet_sdk.labels import DesiredWorkerLabel
 from hatchet_sdk.loader import ClientConfig, ConfigLoader
 from hatchet_sdk.rate_limit import RateLimit
+from hatchet_sdk.v2.callable import HatchetCallable
 
 from .client import Client, new_client, new_client_raw
 from .clients.admin import AdminClient
@@ -36,6 +35,7 @@ from .workflow import (
 )
 
 T = TypeVar("T", bound=BaseModel)
+TWorkflow = TypeVar("TWorkflow", bound=object)
 
 
 def workflow(
@@ -45,30 +45,35 @@ def workflow(
     version: str = "",
     timeout: str = "60m",
     schedule_timeout: str = "5m",
-    sticky: StickyStrategy = None,
+    sticky: Union[StickyStrategy.Value, None] = None,  # type: ignore[name-defined]
     default_priority: int | None = None,
     concurrency: ConcurrencyExpression | None = None,
     input_validator: Type[T] | None = None,
-) -> Callable[[Type[WorkflowInterface]], WorkflowMeta]:
+) -> Callable[[Type[TWorkflow]], WorkflowMeta]:
     on_events = on_events or []
     on_crons = on_crons or []
 
-    def inner(cls: Type[WorkflowInterface]) -> WorkflowMeta:
-        cls.on_events = on_events
-        cls.on_crons = on_crons
-        cls.name = name or str(cls.__name__)
-        cls.version = version
-        cls.timeout = timeout
-        cls.schedule_timeout = schedule_timeout
-        cls.sticky = sticky
-        cls.default_priority = default_priority
-        cls.concurrency_expression = concurrency
+    def inner(cls: Type[TWorkflow]) -> WorkflowMeta:
+        nonlocal name
+        name = name or str(cls.__name__)
+
+        setattr(cls, "on_events", on_events)
+        setattr(cls, "on_crons", on_crons)
+        setattr(cls, "name", name)
+        setattr(cls, "version", version)
+        setattr(cls, "timeout", timeout)
+        setattr(cls, "schedule_timeout", schedule_timeout)
+        setattr(cls, "sticky", sticky)
+        setattr(cls, "default_priority", default_priority)
+        setattr(cls, "concurrency_expression", concurrency)
+
         # Define a new class with the same name and bases as the original, but
         # with WorkflowMeta as its metaclass
 
         ## TODO: Figure out how to type this metaclass correctly
-        cls.input_validator = input_validator
-        return WorkflowMeta(cls.name, cls.__bases__, dict(cls.__dict__))
+        setattr(cls, "input_validator", input_validator)
+
+        return WorkflowMeta(name, cls.__bases__, dict(cls.__dict__))
 
     return inner
 
@@ -82,34 +87,39 @@ def step(
     desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
     backoff_factor: float | None = None,
     backoff_max_seconds: int | None = None,
-) -> Callable[[WorkflowStepProtocol], WorkflowStepProtocol]:
+) -> Callable[..., Any]:
     parents = parents or []
 
-    def inner(func: WorkflowStepProtocol) -> WorkflowStepProtocol:
+    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
         limits = None
         if rate_limits:
             limits = [rate_limit._req for rate_limit in rate_limits or []]
 
-        func._step_name = name.lower() or str(func.__name__).lower()
-        func._step_parents = parents
-        func._step_timeout = timeout
-        func._step_retries = retries
-        func._step_rate_limits = limits
-        func._step_backoff_factor = backoff_factor
-        func._step_backoff_max_seconds = backoff_max_seconds
-
-        func._step_desired_worker_labels = {}
+        setattr(func, "_step_name", name.lower() or str(func.__name__).lower())
+        setattr(func, "_step_parents", parents)
+        setattr(func, "_step_timeout", timeout)
+        setattr(func, "_step_retries", retries)
+        setattr(func, "_step_rate_limits", retries)
+        setattr(func, "_step_rate_limits", limits)
+        setattr(func, "_step_backoff_factor", backoff_factor)
+        setattr(func, "_step_backoff_max_seconds", backoff_max_seconds)
 
-        for key, d in desired_worker_labels.items():
+        def create_label(d: DesiredWorkerLabel) -> DesiredWorkerLabels:
             value = d["value"] if "value" in d else None
-            func._step_desired_worker_labels[key] = DesiredWorkerLabels(
+            return DesiredWorkerLabels(
                 strValue=str(value) if not isinstance(value, int) else None,
                 intValue=value if isinstance(value, int) else None,
-                required=d["required"] if "required" in d else None,
+                required=d["required"] if "required" in d else None,  # type: ignore[arg-type]
                 weight=d["weight"] if "weight" in d else None,
-                comparator=d["comparator"] if "comparator" in d else None,
+                comparator=d["comparator"] if "comparator" in d else None,  # type: ignore[arg-type]
             )
 
+        setattr(
+            func,
+            "_step_desired_worker_labels",
+            {key: create_label(d) for key, d in desired_worker_labels.items()},
+        )
+
         return func
 
     return inner
@@ -122,21 +132,23 @@ def on_failure_step(
     rate_limits: list[RateLimit] | None = None,
     backoff_factor: float | None = None,
     backoff_max_seconds: int | None = None,
-) -> Callable[[WorkflowStepProtocol], WorkflowStepProtocol]:
-    def inner(func: WorkflowStepProtocol) -> WorkflowStepProtocol:
+) -> Callable[..., Any]:
+    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
         limits = None
         if rate_limits:
             limits = [
-                CreateStepRateLimit(key=rate_limit.static_key, units=rate_limit.units)
+                CreateStepRateLimit(key=rate_limit.static_key, units=rate_limit.units)  # type: ignore[arg-type]
                 for rate_limit in rate_limits or []
             ]
 
-        func._on_failure_step_name = name.lower() or str(func.__name__).lower()
-        func._on_failure_step_timeout = timeout
-        func._on_failure_step_retries = retries
-        func._on_failure_step_rate_limits = limits
-        func._on_failure_step_backoff_factor = backoff_factor
-        func._on_failure_step_backoff_max_seconds = backoff_max_seconds
+        setattr(
+            func, "_on_failure_step_name", name.lower() or str(func.__name__).lower()
+        )
+        setattr(func, "_on_failure_step_timeout", timeout)
+        setattr(func, "_on_failure_step_retries", retries)
+        setattr(func, "_on_failure_step_rate_limits", limits)
+        setattr(func, "_on_failure_step_backoff_factor", backoff_factor)
+        setattr(func, "_on_failure_step_backoff_max_seconds", backoff_max_seconds)
 
         return func
 
@@ -147,11 +159,15 @@ def concurrency(
     name: str = "",
     max_runs: int = 1,
     limit_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
-) -> Callable[[WorkflowStepProtocol], WorkflowStepProtocol]:
-    def inner(func: WorkflowStepProtocol) -> WorkflowStepProtocol:
-        func._concurrency_fn_name = name.lower() or str(func.__name__).lower()
-        func._concurrency_max_runs = max_runs
-        func._concurrency_limit_strategy = limit_strategy
+) -> Callable[..., Any]:
+    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
+        setattr(
+            func,
+            "_concurrency_fn_name",
+            name.lower() or str(func.__name__).lower(),
+        )
+        setattr(func, "_concurrency_max_runs", max_runs)
+        setattr(func, "_concurrency_limit_strategy", limit_strategy)
 
         return func
 

hatchet_sdk/labels.py

@@ -1,7 +1,7 @@
 from typing import TypedDict
 
 
-class DesiredWorkerLabel(TypedDict):
+class DesiredWorkerLabel(TypedDict, total=False):
     value: str | int
     required: bool | None = None
     weight: int | None = None

hatchet_sdk/utils/aio_utils.py

@@ -1,10 +1,13 @@
 import asyncio
 import inspect
+from concurrent.futures import Executor
 from functools import partial, wraps
 from threading import Thread
+from typing import Any
 
 
-def sync_to_async(func):
+## TODO: Stricter typing here
+def sync_to_async(func: Any) -> Any:
     """
     A decorator to run a synchronous function or coroutine in an asynchronous context with added
     asyncio loop safety.
@@ -40,8 +43,14 @@ def sync_to_async(func):
         asyncio.run(main())
     """
 
+    ## TODO: Stricter typing here
     @wraps(func)
-    async def run(*args, loop=None, executor=None, **kwargs):
+    async def run(
+        *args: Any,
+        loop: asyncio.AbstractEventLoop | None = None,
+        executor: Executor | None = None,
+        **kwargs: Any
+    ) -> Any:
         """
         The asynchronous wrapper function that runs the given function in an executor.
 
@@ -59,7 +68,7 @@ def sync_to_async(func):
 
         if inspect.iscoroutinefunction(func):
             # Wrap the coroutine to run it in an executor
-            async def wrapper():
+            async def wrapper() -> Any:
                 return await func(*args, **kwargs)
 
             pfunc = partial(asyncio.run, wrapper())
@@ -75,7 +84,7 @@ def sync_to_async(func):
 class EventLoopThread:
     """A class that manages an asyncio event loop running in a separate thread."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """
         Initializes the EventLoopThread by creating an event loop
         and setting up a thread to run the loop.

hatchet_sdk/utils/typing.py

@@ -6,4 +6,7 @@ T = TypeVar("T", bound=BaseModel)
 
 
 def is_basemodel_subclass(model: Any) -> bool:
-    return isinstance(model, type) and issubclass(model, BaseModel)
+    try:
+        return issubclass(model, BaseModel)
+    except TypeError:
+        return False

hatchet_sdk/v2/callable.py

@@ -1,8 +1,19 @@
 import asyncio
-from typing import Callable, Dict, Generic, List, Optional, TypedDict, TypeVar, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    TypedDict,
+    TypeVar,
+    Union,
+)
 
-from hatchet_sdk.context import Context
-from hatchet_sdk.contracts.workflows_pb2 import (
+from hatchet_sdk.clients.admin import ChildTriggerWorkflowOptions
+from hatchet_sdk.context.context import Context
+from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
     CreateStepRateLimit,
     CreateWorkflowJobOpts,
     CreateWorkflowStepOpts,
@@ -28,8 +39,8 @@ class HatchetCallable(Generic[T]):
         durable: bool = False,
         name: str = "",
         auto_register: bool = True,
-        on_events: list | None = None,
-        on_crons: list | None = None,
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str = "",
         timeout: str = "60m",
         schedule_timeout: str = "5m",
@@ -37,8 +48,8 @@ class HatchetCallable(Generic[T]):
         retries: int = 0,
         rate_limits: List[RateLimit] | None = None,
         concurrency: ConcurrencyFunction | None = None,
-        on_failure: Optional["HatchetCallable"] = None,
-        desired_worker_labels: dict[str:DesiredWorkerLabel] = {},
+        on_failure: Union["HatchetCallable[T]", None] = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         default_priority: int | None = None,
     ):
         self.func = func
@@ -85,7 +96,7 @@ class HatchetCallable(Generic[T]):
     def __call__(self, context: Context) -> T:
         return self.func(context)
 
-    def with_namespace(self, namespace: str):
+    def with_namespace(self, namespace: str) -> None:
         if namespace is not None and namespace != "":
             self.function_namespace = namespace
             self.function_name = namespace + self.function_name
@@ -161,21 +172,13 @@ class HatchetCallable(Generic[T]):
         return self.function_namespace + ":" + self.function_name
 
 
-T = TypeVar("T")
-
-
-class TriggerOptions(TypedDict):
-    additional_metadata: Dict[str, str] | None = None
-    sticky: bool | None = None
-
-
 class DurableContext(Context):
     def run(
         self,
-        function: Union[str, HatchetCallable[T]],
-        input: dict = {},
-        key: str = None,
-        options: TriggerOptions = None,
+        function: str | Callable[[Context], Any],
+        input: dict[Any, Any] = {},
+        key: str | None = None,
+        options: ChildTriggerWorkflowOptions | None = None,
     ) -> "RunRef[T]":
         worker_id = self.worker.id()
 

hatchet_sdk/v2/concurrency.py

@@ -1,7 +1,9 @@
-from typing import Callable
+from typing import Any, Callable
 
-from hatchet_sdk.context import Context
-from hatchet_sdk.contracts.workflows_pb2 import ConcurrencyLimitStrategy
+from hatchet_sdk.context.context import Context
+from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
+    ConcurrencyLimitStrategy,
+)
 
 
 class ConcurrencyFunction:
@@ -18,19 +20,19 @@ class ConcurrencyFunction:
         self.limit_strategy = limit_strategy
         self.namespace = "default"
 
-    def set_namespace(self, namespace: str):
+    def set_namespace(self, namespace: str) -> None:
         self.namespace = namespace
 
     def get_action_name(self) -> str:
         return self.namespace + ":" + self.name
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> str:
         return self.func(*args, **kwargs)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.name}({self.max_runs})"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.name}({self.max_runs})"
 
 
@@ -38,7 +40,7 @@ def concurrency(
     name: str = "",
     max_runs: int = 1,
     limit_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
-):
+) -> Callable[[Callable[[Context], str]], ConcurrencyFunction]:
     def inner(func: Callable[[Context], str]) -> ConcurrencyFunction:
         return ConcurrencyFunction(func, name, max_runs, limit_strategy)
 

hatchet_sdk/v2/hatchet.py

@@ -1,36 +1,38 @@
-from typing import Callable, List, Optional, TypeVar
-
-from hatchet_sdk.context import Context
-from hatchet_sdk.contracts.workflows_pb2 import ConcurrencyLimitStrategy, StickyStrategy
+from typing import Any, Callable, TypeVar, Union
+
+from hatchet_sdk import Worker
+from hatchet_sdk.context.context import Context
+from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
+    ConcurrencyLimitStrategy,
+    StickyStrategy,
+)
 from hatchet_sdk.hatchet import Hatchet as HatchetV1
 from hatchet_sdk.hatchet import workflow
 from hatchet_sdk.labels import DesiredWorkerLabel
 from hatchet_sdk.rate_limit import RateLimit
-from hatchet_sdk.v2.callable import HatchetCallable
+from hatchet_sdk.v2.callable import DurableContext, HatchetCallable
 from hatchet_sdk.v2.concurrency import ConcurrencyFunction
 from hatchet_sdk.worker.worker import register_on_worker
 
-from ..worker import Worker
-
 T = TypeVar("T")
 
 
 def function(
     name: str = "",
     auto_register: bool = True,
-    on_events: list | None = None,
-    on_crons: list | None = None,
+    on_events: list[str] | None = None,
+    on_crons: list[str] | None = None,
     version: str = "",
     timeout: str = "60m",
     schedule_timeout: str = "5m",
     sticky: StickyStrategy = None,
     retries: int = 0,
-    rate_limits: List[RateLimit] | None = None,
-    desired_worker_labels: dict[str:DesiredWorkerLabel] = {},
+    rate_limits: list[RateLimit] | None = None,
+    desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
     concurrency: ConcurrencyFunction | None = None,
-    on_failure: Optional["HatchetCallable"] = None,
+    on_failure: Union["HatchetCallable[T]", None] = None,
     default_priority: int | None = None,
-):
+) -> Callable[[Callable[[Context], str]], HatchetCallable[T]]:
     def inner(func: Callable[[Context], T]) -> HatchetCallable[T]:
         return HatchetCallable(
             func=func,
@@ -56,20 +58,20 @@ def function(
 def durable(
     name: str = "",
     auto_register: bool = True,
-    on_events: list | None = None,
-    on_crons: list | None = None,
+    on_events: list[str] | None = None,
+    on_crons: list[str] | None = None,
     version: str = "",
     timeout: str = "60m",
     schedule_timeout: str = "5m",
     sticky: StickyStrategy = None,
     retries: int = 0,
-    rate_limits: List[RateLimit] | None = None,
-    desired_worker_labels: dict[str:DesiredWorkerLabel] = {},
+    rate_limits: list[RateLimit] | None = None,
+    desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
     concurrency: ConcurrencyFunction | None = None,
-    on_failure: HatchetCallable | None = None,
+    on_failure: HatchetCallable[T] | None = None,
     default_priority: int | None = None,
-):
-    def inner(func: HatchetCallable) -> HatchetCallable:
+) -> Callable[[HatchetCallable[T]], HatchetCallable[T]]:
+    def inner(func: HatchetCallable[T]) -> HatchetCallable[T]:
         func.durable = True
 
         f = function(
@@ -102,7 +104,7 @@ def concurrency(
     name: str = "concurrency",
     max_runs: int = 1,
     limit_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
-):
+) -> Callable[[Callable[[Context], str]], ConcurrencyFunction]:
     def inner(func: Callable[[Context], str]) -> ConcurrencyFunction:
         return ConcurrencyFunction(func, name, max_runs, limit_strategy)
 
@@ -113,24 +115,24 @@ class Hatchet(HatchetV1):
     dag = staticmethod(workflow)
     concurrency = staticmethod(concurrency)
 
-    functions: List[HatchetCallable] = []
+    functions: list[HatchetCallable[T]] = []
 
     def function(
         self,
         name: str = "",
         auto_register: bool = True,
-        on_events: list | None = None,
-        on_crons: list | None = None,
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str = "",
         timeout: str = "60m",
         schedule_timeout: str = "5m",
         retries: int = 0,
-        rate_limits: List[RateLimit] | None = None,
-        desired_worker_labels: dict[str:DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         concurrency: ConcurrencyFunction | None = None,
-        on_failure: Optional["HatchetCallable"] = None,
+        on_failure: Union["HatchetCallable[T]", None] = None,
         default_priority: int | None = None,
-    ):
+    ) -> Callable[[Callable[[Context], Any]], Callable[[Context], Any]]:
         resp = function(
             name=name,
             auto_register=auto_register,
@@ -147,7 +149,7 @@ class Hatchet(HatchetV1):
             default_priority=default_priority,
         )
 
-        def wrapper(func: Callable[[Context], T]) -> HatchetCallable[T]:
+        def wrapper(func: Callable[[Context], str]) -> HatchetCallable[T]:
             wrapped_resp = resp(func)
 
             if wrapped_resp.function_auto_register:
@@ -163,19 +165,19 @@ class Hatchet(HatchetV1):
         self,
         name: str = "",
         auto_register: bool = True,
-        on_events: list | None = None,
-        on_crons: list | None = None,
+        on_events: list[str] | None = None,
+        on_crons: list[str] | None = None,
         version: str = "",
         timeout: str = "60m",
         schedule_timeout: str = "5m",
         sticky: StickyStrategy = None,
         retries: int = 0,
-        rate_limits: List[RateLimit] | None = None,
-        desired_worker_labels: dict[str:DesiredWorkerLabel] = {},
+        rate_limits: list[RateLimit] | None = None,
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         concurrency: ConcurrencyFunction | None = None,
-        on_failure: Optional["HatchetCallable"] = None,
+        on_failure: Union["HatchetCallable[T]", None] = None,
         default_priority: int | None = None,
-    ) -> Callable[[HatchetCallable], HatchetCallable]:
+    ) -> Callable[[Callable[[DurableContext], Any]], Callable[[DurableContext], Any]]:
         resp = durable(
             name=name,
             auto_register=auto_register,
@@ -193,7 +195,7 @@ class Hatchet(HatchetV1):
             default_priority=default_priority,
         )
 
-        def wrapper(func: Callable[[Context], T]) -> HatchetCallable[T]:
+        def wrapper(func: HatchetCallable[T]) -> HatchetCallable[T]:
             wrapped_resp = resp(func)
 
             if wrapped_resp.function_auto_register:

hatchet_sdk/worker/runner/runner.py

@@ -21,7 +21,7 @@ from hatchet_sdk.clients.run_event_listener import new_listener
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.context import Context  # type: ignore[attr-defined]
 from hatchet_sdk.context.worker_context import WorkerContext
-from hatchet_sdk.contracts.dispatcher_pb2 import (  # type: ignore[attr-defined]
+from hatchet_sdk.contracts.dispatcher_pb2 import (
     GROUP_KEY_EVENT_TYPE_COMPLETED,
     GROUP_KEY_EVENT_TYPE_FAILED,
     GROUP_KEY_EVENT_TYPE_STARTED,

hatchet_sdk/worker/worker.py

@@ -12,14 +12,15 @@ from multiprocessing.process import BaseProcess
 from types import FrameType
 from typing import Any, Callable, TypeVar, get_type_hints
 
+from pydantic import BaseModel
+
 from hatchet_sdk import Context
 from hatchet_sdk.client import Client, new_client_raw
-from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
-    CreateWorkflowVersionOpts,
-)
+from hatchet_sdk.contracts.workflows_pb2 import CreateWorkflowVersionOpts
 from hatchet_sdk.loader import ClientConfig
 from hatchet_sdk.logger import logger
 from hatchet_sdk.utils.types import WorkflowValidator
+from hatchet_sdk.utils.typing import is_basemodel_subclass
 from hatchet_sdk.v2.callable import HatchetCallable
 from hatchet_sdk.v2.concurrency import ConcurrencyFunction
 from hatchet_sdk.worker.action_listener_process import worker_action_listener_process
@@ -41,6 +42,9 @@ class WorkerStartOptions:
     loop: asyncio.AbstractEventLoop | None = field(default=None)
 
 
+TWorkflow = TypeVar("TWorkflow", bound=object)
+
+
 class Worker:
     def __init__(
         self,
@@ -62,7 +66,7 @@ class Worker:
 
         self.client: Client
 
-        self.action_registry: dict[str, Callable[[Context], T]] = {}
+        self.action_registry: dict[str, Callable[[Context], Any]] = {}
         self.validator_registry: dict[str, WorkflowValidator] = {}
 
         self.killing: bool = False
@@ -84,9 +88,7 @@ class Worker:
 
         self._setup_signal_handlers()
 
-    def register_function(
-        self, action: str, func: HatchetCallable[Any] | ConcurrencyFunction
-    ) -> None:
+    def register_function(self, action: str, func: Callable[[Context], Any]) -> None:
         self.action_registry[action] = func
 
     def register_workflow_from_opts(
@@ -99,7 +101,10 @@ class Worker:
             logger.error(e)
             sys.exit(1)
 
-    def register_workflow(self, workflow: WorkflowInterface) -> None:
+    def register_workflow(self, workflow: TWorkflow) -> None:
+        ## Hack for typing
+        assert isinstance(workflow, WorkflowInterface)
+
         namespace = self.client.config.namespace
 
         try:
@@ -127,8 +132,10 @@ class Worker:
         for action_name, action_func in workflow.get_actions(namespace):
             self.action_registry[action_name] = create_action_function(action_func)
             return_type = get_type_hints(action_func).get("return")
+
             self.validator_registry[action_name] = WorkflowValidator(
-                workflow_input=workflow.input_validator, step_output=return_type
+                workflow_input=workflow.input_validator,
+                step_output=return_type if is_basemodel_subclass(return_type) else None,
             )
 
     def status(self) -> WorkerStatus:

hatchet_sdk/workflow.py

@@ -1,10 +1,20 @@
 import functools
-from typing import Any, Callable, Protocol, Type, TypeVar, Union, cast, get_type_hints
+from typing import (
+    Any,
+    Callable,
+    Protocol,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    get_type_hints,
+    runtime_checkable,
+)
 
 from pydantic import BaseModel
 
 from hatchet_sdk import ConcurrencyLimitStrategy
-from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
+from hatchet_sdk.contracts.workflows_pb2 import (
     CreateWorkflowJobOpts,
     CreateWorkflowStepOpts,
     CreateWorkflowVersionOpts,
@@ -69,6 +79,7 @@ class ConcurrencyExpression:
         self.limit_strategy = limit_strategy
 
 
+@runtime_checkable
 class WorkflowInterface(Protocol):
     def get_name(self, namespace: str) -> str: ...
 
@@ -76,13 +87,13 @@ class WorkflowInterface(Protocol):
 
     def get_create_opts(self, namespace: str) -> Any: ...
 
-    on_events: list[str]
-    on_crons: list[str]
+    on_events: list[str] | None
+    on_crons: list[str] | None
     name: str
     version: str
     timeout: str
     schedule_timeout: str
-    sticky: Union[StickyStrategy.Value, None]
+    sticky: Union[StickyStrategy.Value, None]  # type: ignore[name-defined]
     default_priority: int | None
     concurrency_expression: ConcurrencyExpression | None
     input_validator: Type[BaseModel] | None
@@ -120,6 +131,7 @@ class WorkflowMeta(type):
         @functools.cache
         def get_actions(self: TW, namespace: str) -> StepsType:
             serviceName = get_service_name(namespace)
+
             func_actions = [
                 (serviceName + ":" + func_name, func) for func_name, func in steps
             ]
@@ -165,8 +177,8 @@ class WorkflowMeta(type):
                     inputs="{}",
                     parents=[x for x in func._step_parents],
                     retries=func._step_retries,
-                    rate_limits=func._step_rate_limits,
-                    worker_labels=func._step_desired_worker_labels,
+                    rate_limits=func._step_rate_limits,  # type: ignore[arg-type]
+                    worker_labels=func._step_desired_worker_labels,  # type: ignore[arg-type]
                     backoff_factor=func._step_backoff_factor,
                     backoff_max_seconds=func._step_backoff_max_seconds,
                 )
@@ -196,7 +208,7 @@ class WorkflowMeta(type):
                     "Error: Both concurrencyActions and concurrency_expression are defined. Please use only one concurrency configuration method."
                 )
 
-            on_failure_job: list[CreateWorkflowJobOpts] | None = None
+            on_failure_job: CreateWorkflowJobOpts | None = None
 
             if len(onFailureSteps) > 0:
                 func_name, func = onFailureSteps[0]
@@ -210,7 +222,7 @@ class WorkflowMeta(type):
                             inputs="{}",
                             parents=[],
                             retries=func._on_failure_step_retries,
-                            rate_limits=func._on_failure_step_rate_limits,
+                            rate_limits=func._on_failure_step_rate_limits,  # type: ignore[arg-type]
                             backoff_factor=func._on_failure_step_backoff_factor,
                             backoff_max_seconds=func._on_failure_step_backoff_max_seconds,
                         )

{hatchet_sdk-0.42.3.dist-info → hatchet_sdk-0.42.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 0.42.3
+Version: 0.42.4
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run

{hatchet_sdk-0.42.3.dist-info → hatchet_sdk-0.42.4.dist-info}/RECORD

@@ -1,10 +1,10 @@
 hatchet_sdk/__init__.py,sha256=R5ogd_Dn_6gA_u9a5W2URNq6eDtN1i56cObBv1tOwyU,9408
 hatchet_sdk/client.py,sha256=ajjLd-gZptVuAx25gG_SdAW8xDA4V7HMIhgYuh9MkVY,3486
-hatchet_sdk/clients/admin.py,sha256=rN1T5U7lnrg1FEOUGCD6diqfIsge8SjwnCwn52j0STo,21458
+hatchet_sdk/clients/admin.py,sha256=RGi-cXGTn54EmgiqbUsnb9a9gbA3WFr9Qo2VdBHdSzQ,21530
 hatchet_sdk/clients/dispatcher/action_listener.py,sha256=eOq5z29MhC7ynbOOegDRQr-RqDhpS3gfeLswIlZbuGg,15378
-hatchet_sdk/clients/dispatcher/dispatcher.py,sha256=IA_KFqjuxKmGVLuOQNV0SG_dFpX6PeOR8M6Kpl0fU20,6092
+hatchet_sdk/clients/dispatcher/dispatcher.py,sha256=qTcfIXn9EpfUlafff8Wun_fWTvz-UxOa4i4m6ZVIAnM,6402
 hatchet_sdk/clients/event_ts.py,sha256=ACGvDdfhvK6ZLKdsPxy-PksLhjIU69P9cdH3AxX-X10,728
-hatchet_sdk/clients/events.py,sha256=vPK2UlI1bmrx24mAqGYJQ884yHviVmrGX5qNIBc5-a8,7466
+hatchet_sdk/clients/events.py,sha256=8QOHv4ObSNXb6t5EnaXPwkwr1hN4D087iWn02TRtXb0,7505
 hatchet_sdk/clients/rest/__init__.py,sha256=AQBp3fX79IKrcjUmzLRGFaFKMYBnEbQD9DnwYOHU0jQ,14157
 hatchet_sdk/clients/rest/api/__init__.py,sha256=LaTEK7cYklb8R0iYj727C-jVk-MGHenADN8TJpoIASs,1067
 hatchet_sdk/clients/rest/api/api_token_api.py,sha256=C10FEIHHGBpwq-bIKkrBhvPlg6az4aHlREWEUlJHWl0,33577
@@ -160,9 +160,9 @@ hatchet_sdk/clients/rest/models/workflow.py,sha256=8eRB3hq4U3aipNhpdLZfnDPoBhU6n
 hatchet_sdk/clients/rest/models/workflow_concurrency.py,sha256=RtyT3zGwQtd8upt3xWwqN9O_Frdcu9jQ0Hq9DWmygQ4,3199
 hatchet_sdk/clients/rest/models/workflow_deployment_config.py,sha256=_fjNErg4HnlpHWtapDlKqhMpmUkAdWLQ7DLDMbYkSNE,4510
 hatchet_sdk/clients/rest/models/workflow_kind.py,sha256=JOAMn9bJFWNeR9vKWIbTnrIpCP8d_UXRuqDCjdeqI30,684
-hatchet_sdk/clients/rest/models/workflow_list.py,sha256=2k_TCmVlj4S1USXShf3lekrQ7IOb-LQTSnZn2Ft7AIk,3957
+hatchet_sdk/clients/rest/models/workflow_list.py,sha256=HnWvKZe0PuySA75gZMK7-o6PV4RjWerh_G0SKLAWSn8,3948
 hatchet_sdk/clients/rest/models/workflow_metrics.py,sha256=mslUc2ChUk4hKna-kyflAzgdOcbGk5XqFv_hJ1ujMsI,2877
-hatchet_sdk/clients/rest/models/workflow_run.py,sha256=6trWn7nHyNGIfqTJxWkQRrxXqnTayR0uhlSCgTjr0Ss,6785
+hatchet_sdk/clients/rest/models/workflow_run.py,sha256=nOo94uJw8esygeLTcJRx8TpJN1zq_3Qs-yf9kRTyKk0,6758
 hatchet_sdk/clients/rest/models/workflow_run_cancel200_response.py,sha256=nS_T_uP_ZRwMz-y9DellHrO74hGiLkdlE9z21uH3mh4,2573
 hatchet_sdk/clients/rest/models/workflow_run_list.py,sha256=ZDq7OSw3aLJCSFPPwhBWtGlMpH00B_pns9Ynqdw_QKc,3479
 hatchet_sdk/clients/rest/models/workflow_run_order_by_direction.py,sha256=P-QYH8bwfZmswc1-VxLTmL_bbxiioDlPSQ3TP2350UQ,697
@@ -190,8 +190,8 @@ hatchet_sdk/clients/run_event_listener.py,sha256=51WTg52_aISgYPOFPHJ21rb4IO6aEd7
 hatchet_sdk/clients/workflow_listener.py,sha256=Q_WJcGlZNHJGSpxzDac9wELjgxhP0vLaNTXRy_xnxc8,9466
 hatchet_sdk/connection.py,sha256=593aUGAj7Ouf00lcVwx_pmhdQ9NOC5ANT1Jrf8nwkHs,2165
 hatchet_sdk/context/__init__.py,sha256=Pl_seJ_SJpW34BBZp4KixuZ8GiRK9sJFfegf9u3m7zk,29
-hatchet_sdk/context/context.py,sha256=l0aewPZpncvVzH-L68U-TKH1bMHUuB-4rwXNZ1n69r0,13561
-hatchet_sdk/context/worker_context.py,sha256=1nwq75wnT2zu9Z1fel_TKw0eiMpXJIGAn6HbH1GRVNU,920
+hatchet_sdk/context/context.py,sha256=R2RsPgzBNYi1FJvg4MOowSY-V1Yf69qUmXe3MsAWkyo,13518
+hatchet_sdk/context/worker_context.py,sha256=OVcEWvdT_Kpd0nlg61VAPUgIPSFzSLs0aSrXWj-1GX4,974
 hatchet_sdk/contracts/dispatcher_pb2.py,sha256=W9_Us2_HIdUV5idN2rPwzt4J06JfDeogxwDVvjerk_U,14320
 hatchet_sdk/contracts/dispatcher_pb2.pyi,sha256=2dvxvN4OETOc-OhLNWDntN7GvI4QUxbMiGLdK7FM1wE,18224
 hatchet_sdk/contracts/dispatcher_pb2_grpc.py,sha256=4uJkNig8nssJwS7P-lea1YqE4wl0cVWQaJpOndOdaDs,21453
@@ -203,33 +203,33 @@ hatchet_sdk/contracts/workflows_pb2.pyi,sha256=vq3r4C60MW7qx9735q1kAyGENgfbHZtKe
 hatchet_sdk/contracts/workflows_pb2_grpc.py,sha256=rOC2yF2VqxyGsxHnr1XbKFFh8-eLGic2SXgfS1gU3xM,8864
 hatchet_sdk/features/cron.py,sha256=4lKMH0MqiN8cHJk2jhF0Ueqs6z5ozwJzlOeSeaWqvO0,10217
 hatchet_sdk/features/scheduled.py,sha256=YhEbNWl8dWOH61rXVjAyu8iG1BZqpSkD4kgaxkKIHgY,9504
-hatchet_sdk/hatchet.py,sha256=fnORkj00EYzNYCJZXTlI0i-w50LaOkH8LkDVuNygBaQ,9512
-hatchet_sdk/labels.py,sha256=OuOtOHeZAd1aYi3j_EhgzIGo1_1wDlYokV74xHSuf8Y,259
+hatchet_sdk/hatchet.py,sha256=UpCDv3q-Mrbwi7tFHS2FonBwwXlbs5kRFfCfx4DJVeI,10027
+hatchet_sdk/labels.py,sha256=Axfp1yUNowzE9mL8AQA1ADqwOaNmq3QP_45wb1Ed1aI,272
 hatchet_sdk/loader.py,sha256=dGs6Tt8wdEgHeCBesbbQsP6ZYiARBvoqwIdXIO1P5Os,7913
 hatchet_sdk/logger.py,sha256=5uOr52T4mImSQm1QvWT8HvZFK5WfPNh3Y1cBQZRFgUQ,333
 hatchet_sdk/metadata.py,sha256=M_Cb-CXRKitzVMQHeaHUtbY28ET__fAbyGX1YKaeN4I,80
 hatchet_sdk/rate_limit.py,sha256=IIzpe65i-518t9kQcZVEykDQ2VY8sOw2F7qlQ4wlAjw,4421
 hatchet_sdk/semver.py,sha256=PrgBL0TnyXl3p_OK1iSMk9Gpujfh5asQpJ4DHJLCW2k,998
 hatchet_sdk/token.py,sha256=Ap3jnbaPAL10F2G_D71wj7OpBcvrI3RuE0keqXx1lAE,698
-hatchet_sdk/utils/aio_utils.py,sha256=8woLr_rO3CgzpA_2igTcU133oCxNnQoWCt-PZAWrZ_Q,4072
+hatchet_sdk/utils/aio_utils.py,sha256=D92Z1lc84u8f1mVE3XzOv9XtRKfCIvwfdfL-Bo5fJA8,4336
 hatchet_sdk/utils/backoff.py,sha256=6B5Rb5nLKw_TqqgpJMYjIBV1PTTtbOMRZCveisVhg_I,353
 hatchet_sdk/utils/serialization.py,sha256=P2Uq0yxg-Cea5Lmf6IOh2r7W17MNF1Hv2qxSny6BUk8,451
 hatchet_sdk/utils/tracing.py,sha256=UjTw2vMLg1p6GjOGwt634nYJaNZh8c70PBxOBVLiDQ4,2261
 hatchet_sdk/utils/types.py,sha256=qhx1OoeXh77AN6s4SMaGpB3zK3hPm7ocv-23JFa6_wE,191
-hatchet_sdk/utils/typing.py,sha256=qXhnoQJXjXwuzyZUQ2H3YQ6YW7vL9D_kvmh2kJM5Z9s,233
-hatchet_sdk/v2/callable.py,sha256=FbKj7Eo9SMGuv6SBZQNC6Z8hw1iMTLxbpaW4Dqs4Nn8,6875
-hatchet_sdk/v2/concurrency.py,sha256=aDr8vunzEJOoe2iGxip6M2fbGTde19kJu-UxCNkXQjM,1282
-hatchet_sdk/v2/hatchet.py,sha256=begVaMZmBllykNuyfAvqhL88m5ELBmx7RrJvsL4xdmY,6872
+hatchet_sdk/utils/typing.py,sha256=ab1FdF8OAXjcFq9Ui7Bd6yi8ZX473rIqFAqXJnh5AEM,261
+hatchet_sdk/v2/callable.py,sha256=DqBc3VS7WAk5qU9Ef1HnyAzdgxUq1hDzj-CwQYQrvcA,6948
+hatchet_sdk/v2/concurrency.py,sha256=mRsbCj3G2kwkAJjHOg67y226mYdXVmd0uka3ypdRKUQ,1434
+hatchet_sdk/v2/hatchet.py,sha256=mQZoloWuRCIEwDwXeTaJL2kBjgs9YLHy7UPWxBD5070,7282
 hatchet_sdk/worker/__init__.py,sha256=1Ze1seDuXx5yD1IfHmqGFgK5qrRazVW4ZcDVGl-Pddw,61
 hatchet_sdk/worker/action_listener_process.py,sha256=tmlzDgyHWxGl8fJWE9NKqjvhqpGi9SMmOh5dFyiVL-Q,9979
 hatchet_sdk/worker/runner/run_loop_manager.py,sha256=nV7fhNxJKCcrBm0ci118aszF_7AxenBkOTIe1UsBEt4,3490
-hatchet_sdk/worker/runner/runner.py,sha256=fOzfn9Eh6LWhxYl1dRF_EzKBq-EeTIDzeEuX8V0Wm1o,18547
+hatchet_sdk/worker/runner/runner.py,sha256=uNHPViiQvtwvX4uJ9TqcbFPonJnhhoEM3WNOWEKyop0,18517
 hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=s_BGxeykelVbusx6u31EPx3vv9c2BHkuBnYcaLW680E,2381
 hatchet_sdk/worker/runner/utils/error_with_traceback.py,sha256=Iih_s8JNqrinXETFJ3ZS88EhaTekfM6m5fqIP7QWoIM,181
-hatchet_sdk/worker/worker.py,sha256=fBqTuSnE4lfl-CMTg0FYuw1jE20_CJOwyu2QuzTGdpU,11335
-hatchet_sdk/workflow.py,sha256=qH7lEtR8lvwfP0lHPN2dXJjEh2xmHST19ADW7z82OgM,9209
+hatchet_sdk/worker/worker.py,sha256=R4UEf_1e7qe1LrXS8-0fjfriwcSb3W_38RUR6pOxBCo,11547
+hatchet_sdk/workflow.py,sha256=XRj5jcCQSvPQMXxBipf-ZlARua2E8Z9igRzGcQ5alkI,9375
 hatchet_sdk/workflow_run.py,sha256=BwK5cefvXXvyQ1Ednj_7LeejMwQJqWnvUC_FTBmJNxk,1805
-hatchet_sdk-0.42.3.dist-info/METADATA,sha256=l_KiiLXoE8-zlevPKjK8X7EY4MANc_IPbVT2qev1K9E,1514
-hatchet_sdk-0.42.3.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-hatchet_sdk-0.42.3.dist-info/entry_points.txt,sha256=LTtQRABmSGYOxRI68cUVEz5dp9Qb57eqXGic9lU8RMo,1023
-hatchet_sdk-0.42.3.dist-info/RECORD,,
+hatchet_sdk-0.42.4.dist-info/METADATA,sha256=K_UnsT2BbAX5LRTC9afZNWJfA9wYMS9rk17zhZQ8Aqo,1514
+hatchet_sdk-0.42.4.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+hatchet_sdk-0.42.4.dist-info/entry_points.txt,sha256=LTtQRABmSGYOxRI68cUVEz5dp9Qb57eqXGic9lU8RMo,1023
+hatchet_sdk-0.42.4.dist-info/RECORD,,