hatchet-sdk 1.8.1__py3-none-any.whl → 1.9.0__py3-none-any.whl

hatchet_sdk/config.py

@@ -64,13 +64,20 @@ class ClientConfig(BaseSettings):
     )
 
     worker_preset_labels: dict[str, str] = Field(default_factory=dict)
+
     enable_force_kill_sync_threads: bool = False
+    enable_thread_pool_monitoring: bool = False
 
     @model_validator(mode="after")
     def validate_token_and_tenant(self) -> "ClientConfig":
         if not self.token:
             raise ValueError("Token must be set")
 
+        if not self.token.startswith("ey"):
+            raise ValueError(
+                f"Token must be a valid JWT. Hint: These are the first few characters of the token provided: {self.token[:5]}"
+            )
+
         if not self.tenant_id:
             self.tenant_id = get_tenant_id_from_jwt(self.token)
 

hatchet_sdk/context/context.py

@@ -69,7 +69,7 @@ class Context:
     def trigger_data(self) -> JSONSerializableMapping:
         return self.data.triggers
 
-    def _task_output(self, task: "Task[TWorkflowInput, R]") -> "R":
+    def task_output(self, task: "Task[TWorkflowInput, R]") -> "R":
         from hatchet_sdk.runnables.types import R
 
         if self.was_skipped(task):
@@ -85,19 +85,6 @@ class Context:
 
         return parent_step_data
 
-    def task_output(self, task: "Task[TWorkflowInput, R]") -> "R":
-        from hatchet_sdk.runnables.types import R
-
-        ## If the task is async, we need to wrap its output in a coroutine
-        ## so that the type checker behaves right
-        async def _aio_output() -> "R":
-            return self._task_output(task)
-
-        if task.is_async_function:
-            return cast(R, _aio_output())
-
-        return self._task_output(task)
-
     def aio_task_output(self, task: "Task[TWorkflowInput, R]") -> "R":
         warn(
             "`aio_task_output` is deprecated. Use `task_output` instead.",

hatchet_sdk/hatchet.py

@@ -32,6 +32,7 @@ from hatchet_sdk.runnables.types import (
 )
 from hatchet_sdk.runnables.workflow import BaseWorkflow, Workflow
 from hatchet_sdk.utils.timedelta_to_expression import Duration
+from hatchet_sdk.utils.typing import CoroutineLike
 from hatchet_sdk.worker.worker import LifespanFn, Worker
 
 
@@ -300,7 +301,10 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
-    ) -> Callable[[Callable[[EmptyModel, Context], R]], Standalone[EmptyModel, R]]: ...
+    ) -> Callable[
+        [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
+        Standalone[EmptyModel, R],
+    ]: ...
 
     @overload
     def task(
@@ -323,7 +327,8 @@ class Hatchet:
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]
+        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        Standalone[TWorkflowInput, R],
     ]: ...
 
     def task(
@@ -346,9 +351,13 @@ class Hatchet:
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
     ) -> (
-        Callable[[Callable[[EmptyModel, Context], R]], Standalone[EmptyModel, R]]
+        Callable[
+            [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
+            Standalone[EmptyModel, R],
+        ]
         | Callable[
-            [Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]
+            [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+            Standalone[TWorkflowInput, R],
         ]
     ):
         """
@@ -426,7 +435,7 @@ class Hatchet:
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R]
+            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
         ) -> Standalone[TWorkflowInput, R]:
             created_task = task_wrapper(func)
 
@@ -458,7 +467,8 @@ class Hatchet:
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
     ) -> Callable[
-        [Callable[[EmptyModel, DurableContext], R]], Standalone[EmptyModel, R]
+        [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
+        Standalone[EmptyModel, R],
     ]: ...
 
     @overload
@@ -482,7 +492,8 @@ class Hatchet:
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, DurableContext], R]], Standalone[TWorkflowInput, R]
+        [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+        Standalone[TWorkflowInput, R],
     ]: ...
 
     def durable_task(
@@ -505,9 +516,12 @@ class Hatchet:
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
     ) -> (
-        Callable[[Callable[[EmptyModel, DurableContext], R]], Standalone[EmptyModel, R]]
+        Callable[
+            [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
+            Standalone[EmptyModel, R],
+        ]
         | Callable[
-            [Callable[[TWorkflowInput, DurableContext], R]],
+            [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
             Standalone[TWorkflowInput, R],
         ]
     ):
@@ -579,7 +593,7 @@ class Hatchet:
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, DurableContext], R]
+            func: Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]],
         ) -> Standalone[TWorkflowInput, R]:
             created_task = task_wrapper(func)
 

hatchet_sdk/runnables/task.py

@@ -1,14 +1,5 @@
 from datetime import timedelta
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    Generic,
-    Union,
-    cast,
-    get_type_hints,
-)
+from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast, get_type_hints
 
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.contracts.v1.shared.condition_pb2 import TaskConditions
@@ -27,7 +18,12 @@ from hatchet_sdk.runnables.types import (
     is_sync_fn,
 )
 from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
-from hatchet_sdk.utils.typing import TaskIOValidator, is_basemodel_subclass
+from hatchet_sdk.utils.typing import (
+    AwaitableLike,
+    CoroutineLike,
+    TaskIOValidator,
+    is_basemodel_subclass,
+)
 from hatchet_sdk.waits import (
     Action,
     Condition,
@@ -45,10 +41,10 @@ class Task(Generic[TWorkflowInput, R]):
     def __init__(
         self,
         _fn: Union[
-            Callable[[TWorkflowInput, Context], R]
-            | Callable[[TWorkflowInput, Context], Awaitable[R]],
-            Callable[[TWorkflowInput, DurableContext], R]
-            | Callable[[TWorkflowInput, DurableContext], Awaitable[R]],
+            Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]
+            | Callable[[TWorkflowInput, Context], AwaitableLike[R]],
+            Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]
+            | Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]],
         ],
         is_durable: bool,
         type: StepType,

hatchet_sdk/runnables/types.py

@@ -1,17 +1,17 @@
 import asyncio
 from enum import Enum
-from typing import Any, Awaitable, Callable, ParamSpec, Type, TypeGuard, TypeVar, Union
+from typing import Any, Callable, ParamSpec, Type, TypeGuard, TypeVar, Union
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.contracts.v1.workflows_pb2 import Concurrency
 from hatchet_sdk.utils.timedelta_to_expression import Duration
-from hatchet_sdk.utils.typing import JSONSerializableMapping
+from hatchet_sdk.utils.typing import AwaitableLike, JSONSerializableMapping
 
 ValidTaskReturnType = Union[BaseModel, JSONSerializableMapping, None]
 
-R = TypeVar("R", bound=Union[ValidTaskReturnType, Awaitable[ValidTaskReturnType]])
+R = TypeVar("R", bound=ValidTaskReturnType)
 P = ParamSpec("P")
 
 
@@ -26,8 +26,6 @@ class StickyStrategy(str, Enum):
 
 class ConcurrencyLimitStrategy(str, Enum):
     CANCEL_IN_PROGRESS = "CANCEL_IN_PROGRESS"
-    DROP_NEWEST = "DROP_NEWEST"
-    QUEUE_NEWEST = "QUEUE_NEWEST"
     GROUP_ROUND_ROBIN = "GROUP_ROUND_ROBIN"
     CANCEL_NEWEST = "CANCEL_NEWEST"
 
@@ -82,31 +80,6 @@ class WorkflowConfig(BaseModel):
 
     task_defaults: TaskDefaults = TaskDefaults()
 
-    def _raise_for_invalid_expression(self, expr: str) -> None:
-        if not expr.startswith("input."):
-            return None
-
-        _, field = expr.split(".", maxsplit=2)
-
-        if field not in self.input_validator.model_fields.keys():
-            raise ValueError(
-                f"The concurrency expression provided relies on the `{field}` field, which was not present in `{self.input_validator.__name__}`."
-            )
-
-    @model_validator(mode="after")
-    def validate_concurrency_expression(self) -> "WorkflowConfig":
-        if not self.concurrency:
-            return self
-
-        if isinstance(self.concurrency, list):
-            for item in self.concurrency:
-                self._raise_for_invalid_expression(item.expression)
-
-        if isinstance(self.concurrency, ConcurrencyExpression):
-            self._raise_for_invalid_expression(self.concurrency.expression)
-
-        return self
-
 
 class StepType(str, Enum):
     DEFAULT = "default"
@@ -114,7 +87,7 @@ class StepType(str, Enum):
     ON_SUCCESS = "on_success"
 
 
-AsyncFunc = Callable[[TWorkflowInput, Context], Awaitable[R]]
+AsyncFunc = Callable[[TWorkflowInput, Context], AwaitableLike[R]]
 SyncFunc = Callable[[TWorkflowInput, Context], R]
 TaskFunc = Union[AsyncFunc[TWorkflowInput, R], SyncFunc[TWorkflowInput, R]]
 
@@ -131,7 +104,7 @@ def is_sync_fn(
     return not asyncio.iscoroutinefunction(fn)
 
 
-DurableAsyncFunc = Callable[[TWorkflowInput, DurableContext], Awaitable[R]]
+DurableAsyncFunc = Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]]
 DurableSyncFunc = Callable[[TWorkflowInput, DurableContext], R]
 DurableTaskFunc = Union[
     DurableAsyncFunc[TWorkflowInput, R], DurableSyncFunc[TWorkflowInput, R]

hatchet_sdk/runnables/workflow.py

@@ -35,7 +35,7 @@ from hatchet_sdk.runnables.types import (
 )
 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 JSONSerializableMapping
+from hatchet_sdk.utils.typing import CoroutineLike, JSONSerializableMapping
 from hatchet_sdk.waits import Condition, OrGroup
 from hatchet_sdk.workflow_run import WorkflowRunRef
 
@@ -132,34 +132,6 @@ class BaseWorkflow(Generic[TWorkflowInput]):
     def _create_action_name(self, step: Task[TWorkflowInput, Any]) -> str:
         return self.service_name + ":" + step.name
 
-    def _raise_for_invalid_concurrency(
-        self, concurrency: ConcurrencyExpression
-    ) -> bool:
-        expr = concurrency.expression
-
-        if not expr.startswith("input."):
-            return True
-
-        _, field = expr.split(".", maxsplit=2)
-
-        if field not in self.config.input_validator.model_fields.keys():
-            raise ValueError(
-                f"The concurrency expression provided relies on the `{field}` field, which was not present in `{self.config.input_validator.__name__}`."
-            )
-
-        return True
-
-    def _validate_priority(self, default_priority: int | None) -> int | None:
-        validated_priority = (
-            max(1, min(3, default_priority)) if default_priority else None
-        )
-        if validated_priority != default_priority:
-            logger.warning(
-                "Warning: Default Priority Must be between 1 and 3 -- inclusively. Adjusted to be within the range."
-            )
-
-        return validated_priority
-
     def _is_leaf_task(self, task: Task[TWorkflowInput, Any]) -> bool:
         return not any(task in t.parents for t in self.tasks if task != t)
 
@@ -573,10 +545,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     def _parse_task_name(
         self,
         name: str | None,
-        func: (
-            Callable[[TWorkflowInput, Context], R]
-            | Callable[[TWorkflowInput, DurableContext], R]
-        ),
+        func: Callable[..., Any],
     ) -> str:
         non_null_name = name or func.__name__
 
@@ -597,7 +566,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         wait_for: list[Condition | OrGroup] = [],
         skip_if: list[Condition | OrGroup] = [],
         cancel_if: list[Condition | OrGroup] = [],
-    ) -> Callable[[Callable[[TWorkflowInput, Context], R]], Task[TWorkflowInput, R]]:
+    ) -> Callable[
+        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        Task[TWorkflowInput, R],
+    ]:
         """
         A decorator to transform a function into a Hatchet task that runs as part of a workflow.
 
@@ -640,7 +612,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R]
+            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 _fn=func,
@@ -687,7 +659,8 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         skip_if: list[Condition | OrGroup] = [],
         cancel_if: list[Condition | OrGroup] = [],
     ) -> Callable[
-        [Callable[[TWorkflowInput, DurableContext], R]], Task[TWorkflowInput, R]
+        [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+        Task[TWorkflowInput, R],
     ]:
         """
         A decorator to transform a function into a durable Hatchet task that runs as part of a workflow.
@@ -735,7 +708,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, DurableContext], R]
+            func: Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 _fn=func,
@@ -776,7 +749,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
         concurrency: list[ConcurrencyExpression] = [],
-    ) -> Callable[[Callable[[TWorkflowInput, Context], R]], Task[TWorkflowInput, R]]:
+    ) -> Callable[
+        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        Task[TWorkflowInput, R],
+    ]:
         """
         A decorator to transform a function into a Hatchet on-failure task that runs as the last step in a workflow that had at least one task fail.
 
@@ -800,7 +776,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R]
+            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 is_durable=False,
@@ -836,7 +812,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
         concurrency: list[ConcurrencyExpression] = [],
-    ) -> Callable[[Callable[[TWorkflowInput, Context], R]], Task[TWorkflowInput, R]]:
+    ) -> Callable[
+        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        Task[TWorkflowInput, R],
+    ]:
         """
         A decorator to transform a function into a Hatchet on-success task that runs as the last step in a workflow that had all upstream tasks succeed.
 
@@ -860,7 +839,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R]
+            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 is_durable=False,

hatchet_sdk/utils/typing.py

@@ -1,4 +1,15 @@
-from typing import Any, Mapping, Type, TypeGuard
+import sys
+from typing import (
+    Any,
+    Awaitable,
+    Coroutine,
+    Generator,
+    Mapping,
+    Type,
+    TypeAlias,
+    TypeGuard,
+    TypeVar,
+)
 
 from pydantic import BaseModel
 
@@ -16,3 +27,13 @@ class TaskIOValidator(BaseModel):
 
 
 JSONSerializableMapping = Mapping[str, Any]
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+if sys.version_info >= (3, 12):
+    AwaitableLike: TypeAlias = Awaitable[_T_co]  # noqa: Y047
+    CoroutineLike: TypeAlias = Coroutine[Any, Any, _T_co]  # noqa: Y047
+else:
+    AwaitableLike: TypeAlias = Generator[Any, None, _T_co] | Awaitable[_T_co]
+    CoroutineLike: TypeAlias = Generator[Any, None, _T_co] | Coroutine[Any, Any, _T_co]

hatchet_sdk/worker/action_listener_process.py

@@ -291,6 +291,9 @@ class WorkerActionListenerProcess:
         self.event_queue.put(STOP_LOOP)
 
     async def exit_gracefully(self) -> None:
+        if self.listener:
+            self.listener.stop_signal = True
+
         await self.pause_task_assignment()
 
         if self.killing:

hatchet_sdk/worker/runner/runner.py

@@ -105,6 +105,9 @@ class Runner:
 
         self.lifespan_context = lifespan_context
 
+        if self.config.enable_thread_pool_monitoring:
+            self.start_background_monitoring()
+
     def create_workflow_run_url(self, action: Action) -> str:
         return f"{self.config.server_url}/workflow-runs/{action.workflow_run_id}?tenant={action.tenant_id}"
 
@@ -270,6 +273,47 @@ class Runner:
         finally:
             self.cleanup_run_id(action.key)
 
+    async def log_thread_pool_status(self) -> None:
+        thread_pool_details = {
+            "max_workers": self.slots,
+            "total_threads": len(self.thread_pool._threads),
+            "idle_threads": self.thread_pool._idle_semaphore._value,
+            "active_threads": len(self.threads),
+            "pending_tasks": len(self.tasks),
+            "queue_size": self.thread_pool._work_queue.qsize(),
+            "threads_alive": sum(1 for t in self.thread_pool._threads if t.is_alive()),
+            "threads_daemon": sum(1 for t in self.thread_pool._threads if t.daemon),
+        }
+
+        logger.warning("Thread pool detailed status %s", thread_pool_details)
+
+    async def _start_monitoring(self) -> None:
+        logger.debug("Thread pool monitoring started")
+        try:
+            while True:
+                await self.log_thread_pool_status()
+
+                for key in self.threads.keys():
+                    if key not in self.tasks:
+                        logger.debug(f"Potential zombie thread found for key {key}")
+
+                for key, task in self.tasks.items():
+                    if task.done() and key in self.threads:
+                        logger.debug(
+                            f"Task is done but thread still exists for key {key}"
+                        )
+
+                await asyncio.sleep(60)
+        except asyncio.CancelledError:
+            logger.warning("Thread pool monitoring task cancelled")
+        except Exception as e:
+            logger.exception(f"Error in thread pool monitoring: {e}")
+
+    def start_background_monitoring(self) -> None:
+        loop = asyncio.get_event_loop()
+        self.monitoring_task = loop.create_task(self._start_monitoring())
+        logger.debug("Started thread pool monitoring background task")
+
     def cleanup_run_id(self, key: ActionKey) -> None:
         if key in self.tasks:
             del self.tasks[key]
@@ -419,23 +463,18 @@ class Runner:
         try:
             # call cancel to signal the context to stop
             if key in self.contexts:
-                context = self.contexts.get(key)
-
-                if context:
-                    context._set_cancellation_flag()
+                self.contexts[key]._set_cancellation_flag()
 
             await asyncio.sleep(1)
 
             if key in self.tasks:
-                future = self.tasks.get(key)
-
-                if future:
-                    future.cancel()
+                self.tasks[key].cancel()
 
             # check if thread is still running, if so, print a warning
             if key in self.threads:
-                thread = self.threads.get(key)
-                if thread and self.config.enable_force_kill_sync_threads:
+                thread = self.threads[key]
+
+                if self.config.enable_force_kill_sync_threads:
                     self.force_kill_thread(thread)
                     await asyncio.sleep(1)
 

{hatchet_sdk-1.8.1.dist-info → hatchet_sdk-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.8.1
+Version: 1.9.0
 Summary: 
 License: MIT
 Author: Alexander Belanger

{hatchet_sdk-1.8.1.dist-info → hatchet_sdk-1.9.0.dist-info}/RECORD

@@ -220,10 +220,10 @@ hatchet_sdk/clients/rest/models/workflow_workers_count.py,sha256=qhzqfvjjIDyARki
 hatchet_sdk/clients/rest/rest.py,sha256=zZHTzgl-NBdcK6XhG23m_s9RKRONGPPItzGe407s7GA,9262
 hatchet_sdk/clients/rest/tenacity_utils.py,sha256=n6QvwuGwinLQpiWNU5GxrDNhFBE8_wZdg3WNur21rJ0,1055
 hatchet_sdk/clients/v1/api_client.py,sha256=mJQUZ3cOxlFJiwWKK5F8jBxcpNZ7A2292HucrBqurbg,1205
-hatchet_sdk/config.py,sha256=jJA76BOvVdfOQHy6TKclAvr2qyblcM-Pz5J-hVAdpQ4,3588
+hatchet_sdk/config.py,sha256=Jm-3ja29cpDf2MwfJAJSpL1qCLmYg_CPC29GhN-eUBY,3853
 hatchet_sdk/connection.py,sha256=B5gT5NL9BBB5-l9U_cN6pMlraQk880rEYMnqaK_dgL0,2590
 hatchet_sdk/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hatchet_sdk/context/context.py,sha256=c45AadcE4mm-1ahSoj2khjcdUcYZzqYBQkndxbs2ock,9519
+hatchet_sdk/context/context.py,sha256=CGFqfdaEflG4_um618o8Lo_WPu0UJCJBYZLV8PDibw8,9073
 hatchet_sdk/context/worker_context.py,sha256=OVcEWvdT_Kpd0nlg61VAPUgIPSFzSLs0aSrXWj-1GX4,974
 hatchet_sdk/contracts/dispatcher_pb2.py,sha256=wO-x-NiHjMuC55RArpcvQX7QAjpSrjq1n70mFVwOD0Q,14543
 hatchet_sdk/contracts/dispatcher_pb2.pyi,sha256=iOcGfGtoyvmT58yCrQDvst_o0VPbq1-9rir-0jH_140,18559
@@ -252,7 +252,7 @@ hatchet_sdk/features/runs.py,sha256=9kmn2AM1XVFZS9P_lR-hh6SXwW42Kh73l0WUBl5VJh8,
 hatchet_sdk/features/scheduled.py,sha256=1kNR8AxN1UlabNroU9TtVbptZEXfqTVE25Gxmh2lABs,8928
 hatchet_sdk/features/workers.py,sha256=vD6j7GCttu0fm23_XmBMdE0IuX4mUbL0adgMoC8Sk_E,2571
 hatchet_sdk/features/workflows.py,sha256=PFJsGXTHVfdDBDQ9WcQXcAzr7u-dN7vUpwbZ9fH0ZD8,3976
-hatchet_sdk/hatchet.py,sha256=HRa__owQMeSRhtXzEfObap3ZKxUeNq2FJKOZEUVZ_CI,21795
+hatchet_sdk/hatchet.py,sha256=GYiIAOXUmtVCNCOvWkIOeAGfboxCdiiwPTmd6e5Q9s8,22171
 hatchet_sdk/labels.py,sha256=nATgxWE3lFxRTnfISEpoIRLGbMfAZsHF4lZTuG4Mfic,182
 hatchet_sdk/logger.py,sha256=5uOr52T4mImSQm1QvWT8HvZFK5WfPNh3Y1cBQZRFgUQ,333
 hatchet_sdk/metadata.py,sha256=XkRbhnghJJGCdVvF-uzyGBcNaTqpeQ3uiQvNNP1wyBc,107
@@ -261,14 +261,14 @@ hatchet_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatchet_sdk/rate_limit.py,sha256=TwbCuggiZaWpYuo4mjVLlE-z1OfQ2mRBiVvCSaG3lv4,3919
 hatchet_sdk/runnables/contextvars.py,sha256=6MDocAMmlyiRW37oQ1jyx10tAlJs-xgDjR3xPoPz05g,426
 hatchet_sdk/runnables/standalone.py,sha256=pCAIS40q9ltkK7K97ff79MzE73_k22ymZdrLdFdFwD8,15233
-hatchet_sdk/runnables/task.py,sha256=5VOgi413eH8Gz9_XBxFTfbfLITTpPJYwRB2ZXshysW8,7014
-hatchet_sdk/runnables/types.py,sha256=OBhqa6rvEaY4ypKtUpKHHyQxOXKYvxao_-Hknu5jVns,4802
-hatchet_sdk/runnables/workflow.py,sha256=Ucjguf3SxyJzYe7R427U76iUOLDoHQMzwOQ7g9xYuQA,39765
+hatchet_sdk/runnables/task.py,sha256=AOpULMr3hqxn4W58Lh9oEvsXn_7PPB_c_sIqHRfQn5Q,7063
+hatchet_sdk/runnables/types.py,sha256=5jf1c7_0QVUFh0bcXi4hIiaOdUiyhspU4LltoAFCwlM,3776
+hatchet_sdk/runnables/workflow.py,sha256=6DjM8Qt4ALbxl3_3BQgxdt3FR8tqGCv_JzRIYtrQjzU,38920
 hatchet_sdk/token.py,sha256=KjIiInwG5Kqd_FO4BSW1x_5Uc7PFbnzIVJqr50-ZldE,779
 hatchet_sdk/utils/backoff.py,sha256=6B5Rb5nLKw_TqqgpJMYjIBV1PTTtbOMRZCveisVhg_I,353
 hatchet_sdk/utils/proto_enums.py,sha256=0UybwE3s7TcqmzoQSO8YnhgAKOS8WZXsyPchB8-eksw,1247
 hatchet_sdk/utils/timedelta_to_expression.py,sha256=kwuYZ51JdDdc3h9Sw4vgBFmJBMPkgbGJA4v9uO4_NGk,660
-hatchet_sdk/utils/typing.py,sha256=huflXWR7fvRfIFYdqQIrQmn9jtukzOWoTpW3AXGk5c0,427
+hatchet_sdk/utils/typing.py,sha256=P6-Nd5K_Hk-VhEkGj6LYki_9ddw05rJtzRA56qGXHag,914
 hatchet_sdk/v0/__init__.py,sha256=YNh-0rPHS0rcphmykJ1N2NMfgvERF4oJpBtx3IH_E_M,9657
 hatchet_sdk/v0/client.py,sha256=G1RDZln9Og7tRQulogXkZw8TsVlx7f0VvmtFI_VAe6E,3495
 hatchet_sdk/v0/clients/admin.py,sha256=l6fW21p_3pROz8mVB2QOXX0Pg5poeLXcBNEm6Uids30,18071
@@ -502,13 +502,13 @@ hatchet_sdk/v0/workflow.py,sha256=d4o425efk7J3JgLIge34MW_A3pzwnwSRtwEOgIqM2pc,93
 hatchet_sdk/v0/workflow_run.py,sha256=jsEZprXshrSV7i_TtL5uoCL03D18zQ3NeJCq7mp97Dg,1752
 hatchet_sdk/waits.py,sha256=L2xZUcmrQX-pTVXWv1W8suMoYU_eA0uowpollauQmOM,3893
 hatchet_sdk/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hatchet_sdk/worker/action_listener_process.py,sha256=KxS7-wBpfKnsq0LNSvk-MG442Lh60iQMy3VpD1FW3mU,11703
+hatchet_sdk/worker/action_listener_process.py,sha256=t6COI8KmYoYooFLMZY5KLNPQmJrIrs4luoVZxPnKN_I,11775
 hatchet_sdk/worker/runner/run_loop_manager.py,sha256=RNWKDCjR57nJ0LCoLUMi0_3pnmpqyo80mz_RaxHYGIc,3812
-hatchet_sdk/worker/runner/runner.py,sha256=z8ri-viK_avAfF6zgbVNBc-rztFDbxSwng3RHsof92w,17063
+hatchet_sdk/worker/runner/runner.py,sha256=CdsWl0l4tFp8Yy35uLsR74jNsBs-fIHiDAJZwPSGrKg,18805
 hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=nHRPSiDBqzhObM7i2X7t03OupVFnE7kQBdR2Ckgg-2w,2709
 hatchet_sdk/worker/worker.py,sha256=SfUeYYGfPDVa7Hr1Tdgrzn_A0T-e_apIzW26BhsiB70,16101
 hatchet_sdk/workflow_run.py,sha256=ZwH0HLFGFVXz6jbiqSv4w0Om2XuR52Tzzw6LH4y65jQ,2765
-hatchet_sdk-1.8.1.dist-info/METADATA,sha256=OGkuC1TmJprUiDEHQ9i1eDjhDS6SxMsaX7A22oApNSA,3635
-hatchet_sdk-1.8.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-hatchet_sdk-1.8.1.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
-hatchet_sdk-1.8.1.dist-info/RECORD,,
+hatchet_sdk-1.9.0.dist-info/METADATA,sha256=sxi4zDvyHWlKB65XhEpehELIj0J6-ugHiR9egq78fhU,3635
+hatchet_sdk-1.9.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+hatchet_sdk-1.9.0.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
+hatchet_sdk-1.9.0.dist-info/RECORD,,