hatchet-sdk 1.20.2__py3-none-any.whl → 1.21.0__py3-none-any.whl

hatchet_sdk/context/context.py

@@ -4,6 +4,8 @@ from datetime import timedelta
 from typing import TYPE_CHECKING, Any, cast
 from warnings import warn
 
+from pydantic import TypeAdapter
+
 from hatchet_sdk.clients.admin import AdminClient
 from hatchet_sdk.clients.dispatcher.dispatcher import (  # type: ignore[attr-defined]
     Action,
@@ -25,7 +27,13 @@ from hatchet_sdk.exceptions import TaskRunError
 from hatchet_sdk.features.runs import RunsClient
 from hatchet_sdk.logger import logger
 from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
-from hatchet_sdk.utils.typing import JSONSerializableMapping, LogLevel
+from hatchet_sdk.utils.typing import (
+    JSONSerializableMapping,
+    LogLevel,
+    classify_output_validator,
+    is_basemodel_validator,
+    is_dataclass_validator,
+)
 from hatchet_sdk.worker.runner.utils.capture_logs import AsyncLogSender, LogRecord
 
 if TYPE_CHECKING:
@@ -106,7 +114,21 @@ class Context:
             raise ValueError(f"Step output for '{task.name}' not found") from e
 
         if parent_step_data and (v := task.validators.step_output):
-            return cast(R, v.model_validate(parent_step_data))
+            validator = classify_output_validator(v)
+
+            if is_dataclass_validator(validator):
+                return cast(
+                    R,
+                    TypeAdapter(validator.validator_type).validate_python(
+                        parent_step_data
+                    ),
+                )
+
+            if is_basemodel_validator(validator):
+                return cast(
+                    R,
+                    validator.validator_type.model_validate(parent_step_data),
+                )
 
         return parent_step_data
 

hatchet_sdk/exceptions.py

@@ -167,3 +167,7 @@ class LoopAlreadyRunningError(Exception):
 
 class IllegalTaskOutputError(Exception):
     pass
+
+
+class LifespanSetupError(Exception):
+    pass

hatchet_sdk/hatchet.py

@@ -4,6 +4,8 @@ from collections.abc import Callable
 from datetime import timedelta
 from typing import Any, Concatenate, ParamSpec, cast, overload
 
+from pydantic import BaseModel
+
 from hatchet_sdk import Context, DurableContext
 from hatchet_sdk.client import Client
 from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
@@ -36,7 +38,7 @@ from hatchet_sdk.runnables.types import (
 )
 from hatchet_sdk.runnables.workflow import BaseWorkflow, Standalone, Workflow
 from hatchet_sdk.utils.timedelta_to_expression import Duration
-from hatchet_sdk.utils.typing import CoroutineLike
+from hatchet_sdk.utils.typing import CoroutineLike, DataclassInstance
 from hatchet_sdk.worker.worker import LifespanFn, Worker
 
 P = ParamSpec("P")
@@ -302,8 +304,10 @@ class Hatchet:
                 on_crons=on_crons or [],
                 sticky=sticky,
                 concurrency=concurrency,
-                input_validator=input_validator
-                or cast(type[TWorkflowInput], EmptyModel),
+                input_validator=cast(
+                    type[BaseModel] | type[DataclassInstance],
+                    input_validator or EmptyModel,
+                ),
                 task_defaults=task_defaults,
                 default_priority=default_priority,
                 default_filters=default_filters or [],
@@ -449,8 +453,10 @@ class Hatchet:
                     on_crons=on_crons or [],
                     sticky=sticky,
                     default_priority=default_priority,
-                    input_validator=input_validator
-                    or cast(type[TWorkflowInput], EmptyModel),
+                    input_validator=cast(
+                        type[BaseModel] | type[DataclassInstance],
+                        input_validator or EmptyModel,
+                    ),
                     default_filters=default_filters or [],
                 ),
                 self,
@@ -633,8 +639,10 @@ class Hatchet:
                     on_events=on_events or [],
                     on_crons=on_crons or [],
                     sticky=sticky,
-                    input_validator=input_validator
-                    or cast(type[TWorkflowInput], EmptyModel),
+                    input_validator=cast(
+                        type[BaseModel] | type[DataclassInstance],
+                        input_validator or EmptyModel,
+                    ),
                     default_priority=default_priority,
                     default_filters=default_filters or [],
                 ),

hatchet_sdk/runnables/task.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections.abc import Callable
+from dataclasses import asdict, is_dataclass
 from inspect import Parameter, iscoroutinefunction, signature
 from typing import (
     TYPE_CHECKING,
@@ -37,7 +38,6 @@ from hatchet_sdk.contracts.v1.workflows_pb2 import (
 from hatchet_sdk.exceptions import InvalidDependencyError
 from hatchet_sdk.runnables.types import (
     ConcurrencyExpression,
-    EmptyModel,
     R,
     StepType,
     TWorkflowInput,
@@ -289,11 +289,14 @@ class Task(Generic[TWorkflowInput, R]):
 
         additional_metadata = additional_metadata or {}
         parent_outputs = parent_outputs or {}
+        serialized_input: dict[str, Any] = {}
 
-        if input is None:
-            input = cast(TWorkflowInput, EmptyModel())
+        if is_dataclass(input):
+            serialized_input = asdict(input)
+        elif isinstance(input, BaseModel):
+            serialized_input = input.model_dump()
 
-        action_payload = ActionPayload(input=input.model_dump(), parents=parent_outputs)
+        action_payload = ActionPayload(input=serialized_input, parents=parent_outputs)
 
         action = Action(
             tenant_id=self.workflow.client.config.tenant_id,

hatchet_sdk/runnables/types.py

@@ -4,15 +4,19 @@ from collections.abc import Callable, Mapping
 from enum import Enum
 from typing import Any, ParamSpec, TypeGuard, TypeVar
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, SkipValidation
 
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.contracts.v1.workflows_pb2 import Concurrency
 from hatchet_sdk.contracts.v1.workflows_pb2 import DefaultFilter as DefaultFilterProto
 from hatchet_sdk.utils.timedelta_to_expression import Duration
-from hatchet_sdk.utils.typing import AwaitableLike, JSONSerializableMapping
+from hatchet_sdk.utils.typing import (
+    AwaitableLike,
+    DataclassInstance,
+    JSONSerializableMapping,
+)
 
-ValidTaskReturnType = BaseModel | Mapping[str, Any] | None
+ValidTaskReturnType = BaseModel | Mapping[str, Any] | DataclassInstance | None
 
 R = TypeVar("R", bound=ValidTaskReturnType)
 P = ParamSpec("P")
@@ -56,7 +60,7 @@ class ConcurrencyExpression(BaseModel):
         )
 
 
-TWorkflowInput = TypeVar("TWorkflowInput", bound=BaseModel)
+TWorkflowInput = TypeVar("TWorkflowInput", bound=BaseModel | DataclassInstance)
 
 
 class TaskDefaults(BaseModel):
@@ -93,7 +97,9 @@ 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: SkipValidation[type[BaseModel] | type[DataclassInstance]] = (
+        EmptyModel
+    )
     default_priority: int | None = None
 
     task_defaults: TaskDefaults = TaskDefaults()

hatchet_sdk/runnables/workflow.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections.abc import Callable
+from dataclasses import asdict
 from datetime import datetime, timedelta
 from functools import cached_property
 from typing import (
@@ -16,7 +17,7 @@ from typing import (
 )
 
 from google.protobuf import timestamp_pb2
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel, ConfigDict, SkipValidation, TypeAdapter, model_validator
 
 from hatchet_sdk.clients.admin import (
     ScheduleTriggerWorkflowOptions,
@@ -52,8 +53,12 @@ from hatchet_sdk.utils.proto_enums import convert_python_enum_to_proto
 from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import (
     CoroutineLike,
+    DataclassInstance,
     JSONSerializableMapping,
-    is_basemodel_subclass,
+    classify_output_validator,
+    is_basemodel_validator,
+    is_dataclass_validator,
+    is_no_validator,
 )
 from hatchet_sdk.workflow_run import WorkflowRunRef
 
@@ -130,7 +135,8 @@ def transform_desired_worker_label(d: DesiredWorkerLabel) -> DesiredWorkerLabels
 
 
 class TypedTriggerWorkflowRunConfig(BaseModel, Generic[TWorkflowInput]):
-    input: TWorkflowInput
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    input: SkipValidation[TWorkflowInput]
     options: TriggerWorkflowOptions
 
 
@@ -217,10 +223,26 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         )
 
     def _get_workflow_input(self, ctx: Context) -> TWorkflowInput:
-        return cast(
-            TWorkflowInput,
-            self.config.input_validator.model_validate(ctx.workflow_input),
-        )
+        validator = classify_output_validator(self.config.input_validator)
+
+        if is_dataclass_validator(validator):
+            return cast(
+                TWorkflowInput,
+                TypeAdapter(validator.validator_type).validate_python(
+                    ctx.workflow_input
+                ),
+            )
+
+        if is_basemodel_validator(validator):
+            return cast(
+                TWorkflowInput,
+                validator.validator_type.model_validate(ctx.workflow_input),
+            )
+
+        ## impossible to reach here since the input validator has to be either a BaseModel or dataclass
+
+        self.client.config.logger.error("input validator is of an unknown type")
+        return cast(TWorkflowInput, EmptyModel())
 
     @property
     def input_validator(self) -> type[TWorkflowInput]:
@@ -271,11 +293,16 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         if not input:
             return {}
 
-        if isinstance(input, BaseModel):
-            return input.model_dump(mode="json")
+        validator = classify_output_validator(self.config.input_validator)
+
+        if is_dataclass_validator(validator):
+            return asdict(cast(DataclassInstance, input))
+
+        if is_basemodel_validator(validator):
+            return cast(BaseModel, input).model_dump(mode="json")
 
         raise ValueError(
-            f"Input must be a BaseModel or `None`, got {type(input)} instead."
+            f"Input must be a BaseModel or dataclass, got {type(input)} instead."
         )
 
     @cached_property
@@ -1203,12 +1230,26 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
         return_type = get_type_hints(self._task.fn).get("return")
 
-        self._output_validator = (
-            return_type if is_basemodel_subclass(return_type) else None
-        )
+        self._output_validator = self.get_output_validator(return_type)
 
         self.config = self._workflow.config
 
+    def get_output_validator(
+        self, return_type: Any | None
+    ) -> type[BaseModel] | type[DataclassInstance] | None:
+        validator = classify_output_validator(return_type)
+
+        if is_basemodel_validator(validator):
+            return validator.validator_type
+
+        if is_dataclass_validator(validator):
+            return validator.validator_type
+
+        if is_no_validator(validator):
+            return None
+
+        raise TypeError(f"Unhandled validator type: {validator}")
+
     @overload
     def _extract_result(self, result: dict[str, Any]) -> R: ...
 
@@ -1223,10 +1264,21 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
         output = result.get(self._task.name)
 
-        if not self._output_validator:
+        validator = classify_output_validator(self._output_validator)
+
+        if is_basemodel_validator(validator):
+            return cast(R, validator.validator_type.model_validate(output))
+
+        if is_dataclass_validator(validator):
+            return cast(
+                R,
+                TypeAdapter(validator.validator_type).validate_python(output),
+            )
+
+        if is_no_validator(validator):
             return cast(R, output)
 
-        return cast(R, self._output_validator.model_validate(output))
+        raise TypeError(f"Unhandled validator type: {validator}")
 
     def run(
         self,

hatchet_sdk/utils/typing.py

@@ -1,9 +1,15 @@
 import sys
 from collections.abc import Awaitable, Coroutine, Generator
+from dataclasses import Field as DataclassField
+from dataclasses import dataclass, is_dataclass
 from enum import Enum
-from typing import Any, Literal, TypeAlias, TypeGuard, TypeVar
+from typing import Any, ClassVar, Literal, Protocol, TypeAlias, TypeGuard, TypeVar
 
-from pydantic import BaseModel
+from pydantic import BaseModel, SkipValidation
+
+
+class DataclassInstance(Protocol):
+    __dataclass_fields__: ClassVar[dict[str, DataclassField[Any]]]
 
 
 def is_basemodel_subclass(model: Any) -> TypeGuard[type[BaseModel]]:
@@ -13,9 +19,55 @@ def is_basemodel_subclass(model: Any) -> TypeGuard[type[BaseModel]]:
         return False
 
 
+@dataclass
+class PydanticModelValidator:
+    validator_type: type[BaseModel]
+    kind: Literal["basemodel"] = "basemodel"
+
+
+@dataclass
+class DataclassValidator:
+    validator_type: type[DataclassInstance]
+    kind: Literal["dataclass"] = "dataclass"
+
+
+@dataclass
+class NoValidator:
+    kind: Literal["none"] = "none"
+
+
+OutputValidator = PydanticModelValidator | DataclassValidator | NoValidator
+
+
+def is_basemodel_validator(
+    validator: OutputValidator,
+) -> TypeGuard[PydanticModelValidator]:
+    return validator.kind == "basemodel"
+
+
+def is_dataclass_validator(validator: OutputValidator) -> TypeGuard[DataclassValidator]:
+    return validator.kind == "dataclass"
+
+
+def is_no_validator(validator: OutputValidator) -> TypeGuard[NoValidator]:
+    return validator.kind == "none"
+
+
+def classify_output_validator(return_type: Any | None) -> OutputValidator:
+    if is_basemodel_subclass(return_type):
+        return PydanticModelValidator(validator_type=return_type)
+
+    if is_dataclass(return_type) and isinstance(return_type, type):
+        return DataclassValidator(validator_type=return_type)
+
+    return NoValidator()
+
+
 class TaskIOValidator(BaseModel):
-    workflow_input: type[BaseModel] | None = None
-    step_output: type[BaseModel] | None = None
+    workflow_input: SkipValidation[type[BaseModel] | type[DataclassInstance] | None] = (
+        None
+    )
+    step_output: SkipValidation[type[BaseModel] | type[DataclassInstance] | None] = None
 
 
 JSONSerializableMapping = dict[str, Any]

hatchet_sdk/worker/runner/runner.py

@@ -4,6 +4,7 @@ import functools
 import json
 from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
+from dataclasses import asdict, is_dataclass
 from enum import Enum
 from multiprocessing import Queue
 from textwrap import dedent
@@ -48,6 +49,7 @@ from hatchet_sdk.runnables.contextvars import (
 from hatchet_sdk.runnables.task import Task
 from hatchet_sdk.runnables.types import R, TWorkflowInput
 from hatchet_sdk.utils.serde import remove_null_unicode_character
+from hatchet_sdk.utils.typing import DataclassInstance
 from hatchet_sdk.worker.action_listener_process import ActionEvent
 from hatchet_sdk.worker.runner.utils.capture_logs import (
     AsyncLogSender,
@@ -479,10 +481,12 @@ class Runner:
 
         if isinstance(output, BaseModel):
             output = output.model_dump(mode="json")
+        elif is_dataclass(output):
+            output = asdict(cast(DataclassInstance, output))
 
         if not isinstance(output, dict):
             raise IllegalTaskOutputError(
-                f"Tasks must return either a dictionary or a Pydantic BaseModel which can be serialized to a JSON object. Got object of type {type(output)} instead."
+                f"Tasks must return either a dictionary, a Pydantic BaseModel, or a dataclass which can be serialized to a JSON object. Got object of type {type(output)} instead."
             )
 
         if output is None:

hatchet_sdk/worker/worker.py

@@ -24,7 +24,7 @@ from pydantic import BaseModel
 from hatchet_sdk.client import Client
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.contracts.v1.workflows_pb2 import CreateWorkflowVersionRequest
-from hatchet_sdk.exceptions import LoopAlreadyRunningError
+from hatchet_sdk.exceptions import LifespanSetupError, LoopAlreadyRunningError
 from hatchet_sdk.logger import logger
 from hatchet_sdk.runnables.action import Action
 from hatchet_sdk.runnables.contextvars import task_count
@@ -273,12 +273,18 @@ class Worker:
                 "no actions registered, register workflows or actions before starting worker"
             )
 
-        if self.config.healthcheck.enabled:
-            await self._start_health_server()
-
         lifespan_context = None
         if self.lifespan:
-            lifespan_context = await self._setup_lifespan()
+            try:
+                lifespan_context = await self._setup_lifespan()
+            except LifespanSetupError as e:
+                logger.exception("lifespan setup failed")
+                if self.loop:
+                    self.loop.stop()
+                raise e
+
+        if self.config.healthcheck.enabled:
+            await self._start_health_server()
 
         if self.has_any_non_durable:
             self.action_listener_process = self._start_action_listener(is_durable=False)
@@ -328,8 +334,8 @@ class Worker:
 
         self.lifespan_stack = AsyncExitStack()
 
-        lifespan_gen = self.lifespan()
         try:
+            lifespan_gen = self.lifespan()
             context = await anext(lifespan_gen)
             await self.lifespan_stack.enter_async_context(
                 _create_async_context_manager(lifespan_gen)
@@ -337,10 +343,16 @@ class Worker:
             return context
         except StopAsyncIteration:
             return None
+        except Exception as e:
+            raise LifespanSetupError("An error occurred during lifespan setup") from e
 
     async def _cleanup_lifespan(self) -> None:
-        if self.lifespan_stack is not None:
-            await self.lifespan_stack.aclose()
+        try:
+            if self.lifespan_stack is not None:
+                await self.lifespan_stack.aclose()
+        except Exception as e:
+            logger.exception("error during lifespan cleanup")
+            raise LifespanSetupError("An error occurred during lifespan cleanup") from e
 
     def _start_action_listener(
         self, is_durable: bool
@@ -472,7 +484,10 @@ class Worker:
         ):
             self.durable_action_listener_process.kill()
 
-        await self._cleanup_lifespan()
+        try:
+            await self._cleanup_lifespan()
+        except LifespanSetupError:
+            logger.exception("lifespan cleanup failed")
 
         await self._close()
         if self.loop and self.owned_loop:

{hatchet_sdk-1.20.2.dist-info → hatchet_sdk-1.21.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.20.2
-Summary: 
+Version: 1.21.0
+Summary: This is the official Python SDK for Hatchet, a distributed, fault-tolerant task queue. The SDK allows you to easily integrate Hatchet's task scheduling and workflow orchestration capabilities into your Python applications.
 License: MIT
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run

{hatchet_sdk-1.20.2.dist-info → hatchet_sdk-1.21.0.dist-info}/RECORD

@@ -266,7 +266,7 @@ hatchet_sdk/conditions.py,sha256=CnhpkXgVXM3wc0kAX8KZQA6tp8NFAbdzAN2xFbw7Hb0,452
 hatchet_sdk/config.py,sha256=QVHFVPmqNxc7PFb2Mvll1BGDEmIo9h587N44W7KoYxE,5349
 hatchet_sdk/connection.py,sha256=XCBY9-UxaN3blakgZ59AhDpjb1ilLOOlmNNM6QaDtMM,2961
 hatchet_sdk/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hatchet_sdk/context/context.py,sha256=KE-GsaosBar8USXSj1lkWHdsZXfXFf6tI9RwGTOF-aM,16278
+hatchet_sdk/context/context.py,sha256=8RivrpS0h4BHSXvscjFj933zHNk8OUBDnp1j3CagOu0,16862
 hatchet_sdk/context/worker_context.py,sha256=3lGkOYmDixeuSmqxXbsYav2gErcjP8cDa2m0t0iomjI,884
 hatchet_sdk/contracts/dispatcher_pb2.py,sha256=W9aGh-wctZhLjUXUdeQTxH4qArsw6D0kIAWM9SVCX5o,14786
 hatchet_sdk/contracts/dispatcher_pb2.pyi,sha256=9Qoz88G-btdlTuxvk4knqfnYdcIXy3oR9DTh6MwIdP4,18923
@@ -286,7 +286,7 @@ hatchet_sdk/contracts/v1/workflows_pb2_grpc.py,sha256=XytYpV2kJQZT8iAs14z4SWsv-9
 hatchet_sdk/contracts/workflows_pb2.py,sha256=daEsUwZnlDQ5GGLJ8WHgLdI1Tgr3lBXxGV1mJ6go0nE,11812
 hatchet_sdk/contracts/workflows_pb2.pyi,sha256=WJ3b45pWvoNmmWTWjBJt61IiAoVn61F62AG5OrRsnd8,15538
 hatchet_sdk/contracts/workflows_pb2_grpc.py,sha256=2V8E72DlJx5qlH2yiQpVCu5cQbKUba5X7T1yNrQDF_s,10819
-hatchet_sdk/exceptions.py,sha256=4NC_3CgJhZVF4RYJ6zAb2i4mGqFUL4TiKGSTz99bV-w,4656
+hatchet_sdk/exceptions.py,sha256=jROkq-ZJZteXgK30iqKwtDibqeVqoUG04c_7L9Y2kP4,4704
 hatchet_sdk/features/cel.py,sha256=Uefvm2Du3SJCHiHsp12-URPxXJLe40uv0wK7guFucsE,4002
 hatchet_sdk/features/cron.py,sha256=k6Y-JJBPaf2Dtx-fwvNA2j7lTzHLBZpwVMA_u-p6Lvw,9723
 hatchet_sdk/features/filters.py,sha256=n6PPeRiqd5SOFlcx8V2strUaCGma9JPRAOLx44XpC0o,6443
@@ -299,7 +299,7 @@ hatchet_sdk/features/stubs.py,sha256=5NF43cgZKzh7qzYv_lLae4Xkh_zrz2wMj8M_OoTAAF8
 hatchet_sdk/features/tenant.py,sha256=xkhh5mRKCWbunk_S1iBmGR-DYR-F4mjxk8jLyYUyzNE,886
 hatchet_sdk/features/workers.py,sha256=DVdno28RmtlfhMJUkaPcOMHNKXCPV0RFrXtLqV6zWyE,2600
 hatchet_sdk/features/workflows.py,sha256=WTt58imAFRrEEB3M5hEEIBwNtrzdWbITFpgtsIqJNSM,4770
-hatchet_sdk/hatchet.py,sha256=8p5fjuI7VFlbYths0PyMDMfihcGSMmM4cBAjLm5JZHc,25702
+hatchet_sdk/hatchet.py,sha256=s-R9RQdFz-P8ABnotkcY_cM8XPMzAcFnPOZPKHX_Wlc,25961
 hatchet_sdk/labels.py,sha256=nATgxWE3lFxRTnfISEpoIRLGbMfAZsHF4lZTuG4Mfic,182
 hatchet_sdk/logger.py,sha256=5uOr52T4mImSQm1QvWT8HvZFK5WfPNh3Y1cBQZRFgUQ,333
 hatchet_sdk/metadata.py,sha256=XkRbhnghJJGCdVvF-uzyGBcNaTqpeQ3uiQvNNP1wyBc,107
@@ -308,9 +308,9 @@ hatchet_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatchet_sdk/rate_limit.py,sha256=ptFvHJU9rCzxfcITZEnRkKtJM-SY12WP84FzBwCKAPE,3277
 hatchet_sdk/runnables/action.py,sha256=B9fAKmpseENVjwqL-quHbBmoqbvPgwnypsFfFlDmyeY,4146
 hatchet_sdk/runnables/contextvars.py,sha256=jHrrewUlFPAT9f2u3VCsuSlDBtBoagEUtUzJOSmm4yk,1118
-hatchet_sdk/runnables/task.py,sha256=tNXsUFuua1_DYNeJHodwgOtm_4uX4-5dOp0apGq5h2g,15968
-hatchet_sdk/runnables/types.py,sha256=M23xSMTBPl12CXCCXZ0wbnqZ_sePB6CJKtOdipiNDlg,4362
-hatchet_sdk/runnables/workflow.py,sha256=-oz0q76N-NAi3Xon1VXkzDvZe0ZjbXR_O-3sTCGfokk,58876
+hatchet_sdk/runnables/task.py,sha256=iZjSiHRikh59xzicLibcEYaGNDS3oI8An3f0xhoWw74,16130
+hatchet_sdk/runnables/types.py,sha256=XHLHKAK_4dQlCc-M5nj83LCuAEjtRUrcUJH9P1L-5UM,4512
+hatchet_sdk/runnables/workflow.py,sha256=S_QHwLSVbd_AD9g2ZL9zJWRfwOGeVpDLupsuB99oJl0,60782
 hatchet_sdk/token.py,sha256=KjIiInwG5Kqd_FO4BSW1x_5Uc7PFbnzIVJqr50-ZldE,779
 hatchet_sdk/utils/aio.py,sha256=cu1rD_UZkShtfzi7iXMYwBBaCRdxJQTdUC0_mf8nU2E,499
 hatchet_sdk/utils/backoff.py,sha256=6B5Rb5nLKw_TqqgpJMYjIBV1PTTtbOMRZCveisVhg_I,353
@@ -320,15 +320,15 @@ hatchet_sdk/utils/opentelemetry.py,sha256=Ei_Xbb175O6hwM657uKES9MiHcJa0dyxjA5mzr
 hatchet_sdk/utils/proto_enums.py,sha256=v2gp_ZmIhPxURVXwz5lscllXwZXDl5XGXeL6gezw3o0,1241
 hatchet_sdk/utils/serde.py,sha256=5edZsFddc5KjfbBjHVizPKW6PGgzM5guaLQ5FAFrog8,1769
 hatchet_sdk/utils/timedelta_to_expression.py,sha256=YujnBnGn7lxtkUdKIeqmOiN_ZCGBpRPjCCSzcD3jxzA,644
-hatchet_sdk/utils/typing.py,sha256=zyRsfF-HO_aVhNx_vun-BRCbMWYDBps8aV0NczGUcho,1534
+hatchet_sdk/utils/typing.py,sha256=oHJa8D_-pMWb4OWIevy03hB90woyzRz7Rhs9iNMox7o,2998
 hatchet_sdk/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatchet_sdk/worker/action_listener_process.py,sha256=B-geWWFL3fmCmONaSydOBYpc5T_ctpSzNog9NNPddqE,11528
 hatchet_sdk/worker/runner/run_loop_manager.py,sha256=BcdfxSvZdrxbeTZSUASwCTMKJe6pwLorHVKPTprkM2k,4176
-hatchet_sdk/worker/runner/runner.py,sha256=B546JN14g7RtRe7qeXs2cSgfosO3bJa8AkZ1a2NLe1k,19170
+hatchet_sdk/worker/runner/runner.py,sha256=sqCI99oTs8nfdiQGVzc9Rwik4lJOprN5doPSBnPIkSU,19380
 hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=hNELuNHS0HmoMZJ7F7yIjZuahPEx9cOx9JZro618W74,4675
-hatchet_sdk/worker/worker.py,sha256=BP8A70hQxNvJ8VG8Osb5NTE4mwdcmEkiLwdtwkkNbuE,16868
+hatchet_sdk/worker/worker.py,sha256=bYr9wwl_YtmGlGMzBnc8H4E7peOTftJkUqf5HLmTLWs,17535
 hatchet_sdk/workflow_run.py,sha256=KcylcqRwKADtnzOTjoiVr1vdr7qTZFtDeD5aRS6A4Y8,2823
-hatchet_sdk-1.20.2.dist-info/METADATA,sha256=XmaVFuL278B4_a8Dn2U49u2EU5Jngd7AeSKoRLV-FPk,3343
-hatchet_sdk-1.20.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-hatchet_sdk-1.20.2.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
-hatchet_sdk-1.20.2.dist-info/RECORD,,
+hatchet_sdk-1.21.0.dist-info/METADATA,sha256=6vsYh3ygnkf9CAuxTu0UCLyv5-JKP-T_kR__J9BlWZs,3565
+hatchet_sdk-1.21.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+hatchet_sdk-1.21.0.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
+hatchet_sdk-1.21.0.dist-info/RECORD,,