hatchet-sdk 1.16.5__py3-none-any.whl → 1.17.0__py3-none-any.whl

hatchet_sdk/__init__.py

@@ -155,7 +155,7 @@ from hatchet_sdk.exceptions import (
 from hatchet_sdk.features.cel import CELEvaluationResult, CELFailure, CELSuccess
 from hatchet_sdk.features.runs import BulkCancelReplayOpts, RunFilter
 from hatchet_sdk.hatchet import Hatchet
-from hatchet_sdk.runnables.task import Task
+from hatchet_sdk.runnables.task import Depends, Task
 from hatchet_sdk.runnables.types import (
     ConcurrencyExpression,
     ConcurrencyLimitStrategy,
@@ -198,6 +198,7 @@ __all__ = [
     "CreateWorkflowVersionOpts",
     "DedupeViolationError",
     "DefaultFilter",
+    "Depends",
     "DurableContext",
     "EmptyModel",
     "Event",

hatchet_sdk/clients/events.py

@@ -28,7 +28,7 @@ from hatchet_sdk.contracts.events_pb2 import (
 )
 from hatchet_sdk.contracts.events_pb2_grpc import EventsServiceStub
 from hatchet_sdk.metadata import get_metadata
-from hatchet_sdk.utils.typing import JSONSerializableMapping
+from hatchet_sdk.utils.typing import JSONSerializableMapping, LogLevel
 
 
 def proto_timestamp_now() -> timestamp_pb2.Timestamp:
@@ -180,11 +180,14 @@ class EventClient(BaseRestClient):
         )
 
     @tenacity_retry
-    def log(self, message: str, step_run_id: str) -> None:
+    def log(
+        self, message: str, step_run_id: str, level: LogLevel | None = None
+    ) -> None:
         request = PutLogRequest(
             stepRunId=step_run_id,
             createdAt=proto_timestamp_now(),
             message=message,
+            level=level.value if level else None,
         )
 
         self.events_service_client.PutLog(request, metadata=get_metadata(self.token))

hatchet_sdk/context/context.py

@@ -21,10 +21,11 @@ from hatchet_sdk.conditions import (
     flatten_conditions,
 )
 from hatchet_sdk.context.worker_context import WorkerContext
+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
+from hatchet_sdk.utils.typing import JSONSerializableMapping, LogLevel
 from hatchet_sdk.worker.runner.utils.capture_logs import AsyncLogSender, LogRecord
 
 if TYPE_CHECKING:
@@ -211,7 +212,9 @@ class Context:
                 line = str(line)
 
         logger.info(line)
-        self.log_sender.publish(LogRecord(message=line, step_run_id=self.step_run_id))
+        self.log_sender.publish(
+            LogRecord(message=line, step_run_id=self.step_run_id, level=LogLevel.INFO)
+        )
 
     def release_slot(self) -> None:
         """
@@ -360,15 +363,41 @@ class Context:
         task: "Task[TWorkflowInput, R]",
     ) -> str | None:
         """
+        **DEPRECATED**: Use `get_task_run_error` instead.
+
         A helper intended to be used in an on-failure step to retrieve the error that occurred in a specific upstream task run.
 
         :param task: The task whose error you want to retrieve.
         :return: The error message of the task run, or None if no error occurred.
         """
+        warn(
+            "`fetch_task_run_error` is deprecated. Use `get_task_run_error` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         errors = self.data.step_run_errors
 
         return errors.get(task.name)
 
+    def get_task_run_error(
+        self,
+        task: "Task[TWorkflowInput, R]",
+    ) -> TaskRunError | None:
+        """
+        A helper intended to be used in an on-failure step to retrieve the error that occurred in a specific upstream task run.
+
+        :param task: The task whose error you want to retrieve.
+        :return: The error message of the task run, or None if no error occurred.
+        """
+        errors = self.data.step_run_errors
+
+        error = errors.get(task.name)
+
+        if not error:
+            return None
+
+        return TaskRunError.deserialize(error)
+
 
 class DurableContext(Context):
     def __init__(

hatchet_sdk/exceptions.py

@@ -1,4 +1,10 @@
+import json
 import traceback
+from typing import cast
+
+
+class InvalidDependencyError(Exception):
+    pass
 
 
 class NonRetryableException(Exception):  # noqa: N818
@@ -9,28 +15,42 @@ class DedupeViolationError(Exception):
     """Raised by the Hatchet library to indicate that a workflow has already been run with this deduplication value."""
 
 
+TASK_RUN_ERROR_METADATA_KEY = "__hatchet_error_metadata__"
+
+
 class TaskRunError(Exception):
     def __init__(
         self,
         exc: str,
         exc_type: str,
         trace: str,
+        task_run_external_id: str | None,
     ) -> None:
         self.exc = exc
         self.exc_type = exc_type
         self.trace = trace
+        self.task_run_external_id = task_run_external_id
 
     def __str__(self) -> str:
-        return self.serialize()
+        return self.serialize(include_metadata=False)
 
     def __repr__(self) -> str:
         return str(self)
 
-    def serialize(self) -> str:
+    def serialize(self, include_metadata: bool) -> str:
         if not self.exc_type or not self.exc:
             return ""
 
-        return (
+        metadata = json.dumps(
+            {
+                TASK_RUN_ERROR_METADATA_KEY: {
+                    "task_run_external_id": self.task_run_external_id,
+                }
+            },
+            indent=None,
+        )
+
+        result = (
             self.exc_type.replace(": ", ":::")
             + ": "
             + self.exc.replace("\n", "\\\n")
@@ -38,6 +58,40 @@ class TaskRunError(Exception):
             + self.trace
         )
 
+        if include_metadata:
+            return result + "\n\n" + metadata
+
+        return result
+
+    @classmethod
+    def _extract_metadata(cls, serialized: str) -> tuple[str, dict[str, str | None]]:
+        metadata = serialized.split("\n")[-1]
+
+        try:
+            parsed = json.loads(metadata)
+
+            if (
+                TASK_RUN_ERROR_METADATA_KEY in parsed
+                and "task_run_external_id" in parsed[TASK_RUN_ERROR_METADATA_KEY]
+            ):
+                serialized = serialized.replace(metadata, "").strip()
+                return serialized, cast(
+                    dict[str, str | None], parsed[TASK_RUN_ERROR_METADATA_KEY]
+                )
+
+            return serialized, {}
+        except json.JSONDecodeError:
+            return serialized, {}
+
+    @classmethod
+    def _unpack_serialized_error(cls, serialized: str) -> tuple[str | None, str, str]:
+        serialized, metadata = cls._extract_metadata(serialized)
+
+        external_id = metadata.get("task_run_external_id", None)
+        header, trace = serialized.split("\n", 1)
+
+        return external_id, header, trace
+
     @classmethod
     def deserialize(cls, serialized: str) -> "TaskRunError":
         if not serialized:
@@ -45,10 +99,16 @@ class TaskRunError(Exception):
                 exc="",
                 exc_type="",
                 trace="",
+                task_run_external_id=None,
             )
 
+        task_run_external_id = None
+
         try:
-            header, trace = serialized.split("\n", 1)
+            task_run_external_id, header, trace = cls._unpack_serialized_error(
+                serialized
+            )
+
             exc_type, exc = header.split(": ", 1)
         except ValueError:
             ## If we get here, we saw an error that was not serialized how we expected,
@@ -57,6 +117,7 @@ class TaskRunError(Exception):
                 exc=serialized,
                 exc_type="HatchetError",
                 trace="",
+                task_run_external_id=task_run_external_id,
             )
 
         exc_type = exc_type.replace(":::", ": ")
@@ -66,16 +127,20 @@ class TaskRunError(Exception):
             exc=exc,
             exc_type=exc_type,
             trace=trace,
+            task_run_external_id=task_run_external_id,
         )
 
     @classmethod
-    def from_exception(cls, exc: Exception) -> "TaskRunError":
+    def from_exception(
+        cls, exc: Exception, task_run_external_id: str | None
+    ) -> "TaskRunError":
         return cls(
             exc=str(exc),
             exc_type=type(exc).__name__,
             trace="".join(
                 traceback.format_exception(type(exc), exc, exc.__traceback__)
             ),
+            task_run_external_id=task_run_external_id,
         )
 
 

hatchet_sdk/hatchet.py

@@ -3,7 +3,7 @@ import logging
 from collections.abc import Callable
 from datetime import timedelta
 from functools import cached_property
-from typing import Any, cast, overload
+from typing import Any, Concatenate, ParamSpec, cast, overload
 
 from hatchet_sdk import Context, DurableContext
 from hatchet_sdk.client import Client
@@ -40,6 +40,8 @@ from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import CoroutineLike
 from hatchet_sdk.worker.worker import LifespanFn, Worker
 
+P = ParamSpec("P")
+
 
 class Hatchet:
     """
@@ -346,7 +348,7 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[EmptyModel, Context, P], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
     ]: ...
 
@@ -372,7 +374,7 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Standalone[TWorkflowInput, R],
     ]: ...
 
@@ -398,11 +400,11 @@ class Hatchet:
         default_filters: list[DefaultFilter] | None = None,
     ) -> (
         Callable[
-            [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
+            [Callable[Concatenate[EmptyModel, Context, P], R | CoroutineLike[R]]],
             Standalone[EmptyModel, R],
         ]
         | Callable[
-            [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+            [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
             Standalone[TWorkflowInput, R],
         ]
     ):
@@ -447,7 +449,9 @@ class Hatchet:
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Standalone[TWorkflowInput, R]:
             inferred_name = name or func.__name__
 
@@ -518,7 +522,7 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
+        [Callable[Concatenate[EmptyModel, DurableContext, P], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
     ]: ...
 
@@ -544,7 +548,11 @@ class Hatchet:
         backoff_max_seconds: int | None = None,
         default_filters: list[DefaultFilter] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+        [
+            Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ]
+        ],
         Standalone[TWorkflowInput, R],
     ]: ...
 
@@ -570,11 +578,19 @@ class Hatchet:
         default_filters: list[DefaultFilter] | None = None,
     ) -> (
         Callable[
-            [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
+            [
+                Callable[
+                    Concatenate[EmptyModel, DurableContext, P], R | CoroutineLike[R]
+                ]
+            ],
             Standalone[EmptyModel, R],
         ]
         | Callable[
-            [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+            [
+                Callable[
+                    Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+                ]
+            ],
             Standalone[TWorkflowInput, R],
         ]
     ):
@@ -619,7 +635,9 @@ class Hatchet:
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ],
         ) -> Standalone[TWorkflowInput, R]:
             inferred_name = name or func.__name__
             workflow = Workflow[TWorkflowInput](

hatchet_sdk/rate_limit.py

@@ -1,20 +1,10 @@
 from enum import Enum
 
-from celpy import CELEvalError, Environment  # type: ignore
 from pydantic import BaseModel, model_validator
 
 from hatchet_sdk.contracts.v1.workflows_pb2 import CreateTaskRateLimit
 
 
-def validate_cel_expression(expr: str) -> bool:
-    env = Environment()
-    try:
-        env.compile(expr)
-        return True
-    except CELEvalError:
-        return False
-
-
 class RateLimitDuration(str, Enum):
     SECOND = "SECOND"
     MINUTE = "MINUTE"
@@ -72,17 +62,7 @@ class RateLimit(BaseModel):
         if self.dynamic_key and self.static_key:
             raise ValueError("Cannot have both static key and dynamic key set")
 
-        if self.dynamic_key and not validate_cel_expression(self.dynamic_key):
-            raise ValueError(f"Invalid CEL expression: {self.dynamic_key}")
-
-        if not isinstance(self.units, int) and not validate_cel_expression(self.units):
-            raise ValueError(f"Invalid CEL expression: {self.units}")
-
-        if (
-            self.limit
-            and not isinstance(self.limit, int)
-            and not validate_cel_expression(self.limit)
-        ):
+        if self.limit and not isinstance(self.limit, int):
             raise ValueError(f"Invalid CEL expression: {self.limit}")
 
         if self.dynamic_key and not self.limit:

hatchet_sdk/runnables/task.py

@@ -1,5 +1,21 @@
+import asyncio
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, Generic, cast, get_type_hints
+from inspect import Parameter, iscoroutinefunction, signature
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Concatenate,
+    Generic,
+    ParamSpec,
+    TypeVar,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from pydantic import BaseModel, ConfigDict
 
 from hatchet_sdk.conditions import (
     Action,
@@ -18,6 +34,7 @@ from hatchet_sdk.contracts.v1.workflows_pb2 import (
     CreateTaskRateLimit,
     DesiredWorkerLabels,
 )
+from hatchet_sdk.exceptions import InvalidDependencyError
 from hatchet_sdk.runnables.types import (
     ConcurrencyExpression,
     EmptyModel,
@@ -25,7 +42,6 @@ from hatchet_sdk.runnables.types import (
     StepType,
     TWorkflowInput,
     is_async_fn,
-    is_durable_sync_fn,
     is_sync_fn,
 )
 from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
@@ -41,16 +57,45 @@ from hatchet_sdk.worker.runner.utils.capture_logs import AsyncLogSender
 if TYPE_CHECKING:
     from hatchet_sdk.runnables.workflow import Workflow
 
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+class Depends(Generic[T, TWorkflowInput]):
+    def __init__(
+        self, fn: Callable[[TWorkflowInput, Context], T | CoroutineLike[T]]
+    ) -> None:
+        sig = signature(fn)
+        params = list(sig.parameters.values())
+
+        if len(params) != 2:
+            raise InvalidDependencyError(
+                f"Dependency function {fn.__name__} must have exactly two parameters: input and ctx."
+            )
+
+        self.fn = fn
+
+
+class DependencyToInject(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: str
+    value: Any
+
 
 class Task(Generic[TWorkflowInput, R]):
     def __init__(
         self,
         _fn: (
-            Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]
-            | Callable[[TWorkflowInput, Context], AwaitableLike[R]]
+            Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]
+            | Callable[Concatenate[TWorkflowInput, Context, P], AwaitableLike[R]]
             | (
-                Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]
-                | Callable[[TWorkflowInput, DurableContext], AwaitableLike[R]]
+                Callable[
+                    Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+                ]
+                | Callable[
+                    Concatenate[TWorkflowInput, DurableContext, P], AwaitableLike[R]
+                ]
             )
         ),
         is_durable: bool,
@@ -100,33 +145,74 @@ class Task(Generic[TWorkflowInput, R]):
             step_output=return_type if is_basemodel_subclass(return_type) else None,
         )
 
-    def call(self, ctx: Context | DurableContext) -> R:
+    async def _parse_parameter(
+        self,
+        name: str,
+        param: Parameter,
+        input: TWorkflowInput,
+        ctx: Context | DurableContext,
+    ) -> DependencyToInject | None:
+        annotation = param.annotation
+
+        if get_origin(annotation) is Annotated:
+            args = get_args(annotation)
+
+            if len(args) < 2:
+                return None
+
+            metadata = args[1:]
+
+            for item in metadata:
+                if isinstance(item, Depends):
+                    if iscoroutinefunction(item.fn):
+                        return DependencyToInject(
+                            name=name, value=await item.fn(input, ctx)
+                        )
+
+                    return DependencyToInject(
+                        name=name, value=await asyncio.to_thread(item.fn, input, ctx)
+                    )
+
+        return None
+
+    async def _unpack_dependencies(
+        self, ctx: Context | DurableContext
+    ) -> dict[str, Any]:
+        sig = signature(self.fn)
+        input = self.workflow._get_workflow_input(ctx)
+        return {
+            parsed.name: parsed.value
+            for n, p in sig.parameters.items()
+            if (parsed := await self._parse_parameter(n, p, input, ctx)) is not None
+        }
+
+    def call(
+        self, ctx: Context | DurableContext, dependencies: dict[str, Any] | None = None
+    ) -> R:
         if self.is_async_function:
             raise TypeError(f"{self.name} is not a sync function. Use `acall` instead.")
 
         workflow_input = self.workflow._get_workflow_input(ctx)
+        dependencies = dependencies or {}
 
-        if self.is_durable:
-            fn = cast(Callable[[TWorkflowInput, DurableContext], R], self.fn)
-            if is_durable_sync_fn(fn):
-                return fn(workflow_input, cast(DurableContext, ctx))
-        else:
-            fn = cast(Callable[[TWorkflowInput, Context], R], self.fn)
-            if is_sync_fn(fn):
-                return fn(workflow_input, ctx)
+        if is_sync_fn(self.fn):  # type: ignore
+            return self.fn(workflow_input, cast(Context, ctx), **dependencies)  # type: ignore
 
         raise TypeError(f"{self.name} is not a sync function. Use `acall` instead.")
 
-    async def aio_call(self, ctx: Context | DurableContext) -> R:
+    async def aio_call(
+        self, ctx: Context | DurableContext, dependencies: dict[str, Any] | None = None
+    ) -> R:
         if not self.is_async_function:
             raise TypeError(
                 f"{self.name} is not an async function. Use `call` instead."
             )
 
         workflow_input = self.workflow._get_workflow_input(ctx)
+        dependencies = dependencies or {}
 
         if is_async_fn(self.fn):  # type: ignore
-            return await self.fn(workflow_input, cast(Context, ctx))  # type: ignore
+            return await self.fn(workflow_input, cast(Context, ctx), **dependencies)  # type: ignore
 
         raise TypeError(f"{self.name} is not an async function. Use `call` instead.")
 
@@ -255,6 +341,7 @@ class Task(Generic[TWorkflowInput, R]):
         parent_outputs: dict[str, JSONSerializableMapping] | None = None,
         retry_count: int = 0,
         lifespan: Any = None,
+        dependencies: dict[str, Any] | None = None,
     ) -> R:
         """
         Mimic the execution of a task. This method is intended to be used to unit test
@@ -266,6 +353,7 @@ class Task(Generic[TWorkflowInput, R]):
         :param parent_outputs: Outputs from parent tasks, if any. This is useful for mimicking DAG functionality. For instance, if you have a task `step_2` that has a `parent` which is `step_1`, you can pass `parent_outputs={"step_1": {"result": "Hello, world!"}}` to `step_2.mock_run()` to be able to access `ctx.task_output(step_1)` in `step_2`.
         :param retry_count: The number of times the task has been retried.
         :param lifespan: The lifespan to be used in the task, which is useful if one was set on the worker. This will allow you to access `ctx.lifespan` inside of your task.
+        :param dependencies: Dependencies to be injected into the task. This is useful for tasks that have dependencies defined using `Depends`. **IMPORTANT**: You must pass the dependencies _directly_, **not** the `Depends` objects themselves. For example, if you have a task that has a dependency `config: Annotated[str, Depends(get_config)]`, you should pass `dependencies={"config": "config_value"}` to `aio_mock_run`.
 
         :return: The output of the task.
         :raises TypeError: If the task is an async function and `mock_run` is called, or if the task is a sync function and `aio_mock_run` is called.
@@ -280,7 +368,7 @@ class Task(Generic[TWorkflowInput, R]):
             input, additional_metadata, parent_outputs, retry_count, lifespan
         )
 
-        return self.call(ctx)
+        return self.call(ctx, dependencies)
 
     async def aio_mock_run(
         self,
@@ -289,6 +377,7 @@ class Task(Generic[TWorkflowInput, R]):
         parent_outputs: dict[str, JSONSerializableMapping] | None = None,
         retry_count: int = 0,
         lifespan: Any = None,
+        dependencies: dict[str, Any] | None = None,
     ) -> R:
         """
         Mimic the execution of a task. This method is intended to be used to unit test
@@ -300,6 +389,7 @@ class Task(Generic[TWorkflowInput, R]):
         :param parent_outputs: Outputs from parent tasks, if any. This is useful for mimicking DAG functionality. For instance, if you have a task `step_2` that has a `parent` which is `step_1`, you can pass `parent_outputs={"step_1": {"result": "Hello, world!"}}` to `step_2.mock_run()` to be able to access `ctx.task_output(step_1)` in `step_2`.
         :param retry_count: The number of times the task has been retried.
         :param lifespan: The lifespan to be used in the task, which is useful if one was set on the worker. This will allow you to access `ctx.lifespan` inside of your task.
+        :param dependencies: Dependencies to be injected into the task. This is useful for tasks that have dependencies defined using `Depends`. **IMPORTANT**: You must pass the dependencies _directly_, **not** the `Depends` objects themselves. For example, if you have a task that has a dependency `config: Annotated[str, Depends(get_config)]`, you should pass `dependencies={"config": "config_value"}` to `aio_mock_run`.
 
         :return: The output of the task.
         :raises TypeError: If the task is an async function and `mock_run` is called, or if the task is a sync function and `aio_mock_run` is called.
@@ -318,4 +408,4 @@ class Task(Generic[TWorkflowInput, R]):
             lifespan,
         )
 
-        return await self.aio_call(ctx)
+        return await self.aio_call(ctx, dependencies)

hatchet_sdk/runnables/workflow.py

@@ -5,8 +5,10 @@ from functools import cached_property
 from typing import (
     TYPE_CHECKING,
     Any,
+    Concatenate,
     Generic,
     Literal,
+    ParamSpec,
     TypeVar,
     cast,
     get_type_hints,
@@ -60,6 +62,7 @@ if TYPE_CHECKING:
 
 
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
 def fall_back_to_default(value: T, param_default: T, fallback_value: T | None) -> T:
@@ -800,7 +803,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         skip_if: list[Condition | OrGroup] | None = None,
         cancel_if: list[Condition | OrGroup] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -845,7 +848,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 _fn=func,
@@ -892,7 +897,11 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         skip_if: list[Condition | OrGroup] | None = None,
         cancel_if: list[Condition | OrGroup] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
+        [
+            Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ]
+        ],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -941,7 +950,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         )
 
         def inner(
-            func: Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, DurableContext, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 _fn=func,
@@ -983,7 +994,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         backoff_max_seconds: int | None = None,
         concurrency: list[ConcurrencyExpression] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -1009,7 +1020,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 is_durable=False,
@@ -1051,7 +1064,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         backoff_max_seconds: int | None = None,
         concurrency: list[ConcurrencyExpression] | None = None,
     ) -> Callable[
-        [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
+        [Callable[Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]]],
         Task[TWorkflowInput, R],
     ]:
         """
@@ -1077,7 +1090,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         """
 
         def inner(
-            func: Callable[[TWorkflowInput, Context], R | CoroutineLike[R]],
+            func: Callable[
+                Concatenate[TWorkflowInput, Context, P], R | CoroutineLike[R]
+            ],
         ) -> Task[TWorkflowInput, R]:
             task = Task(
                 is_durable=False,

hatchet_sdk/utils/typing.py

@@ -1,5 +1,6 @@
 import sys
 from collections.abc import Awaitable, Coroutine, Generator
+from enum import Enum
 from typing import Any, Literal, TypeAlias, TypeGuard, TypeVar
 
 from pydantic import BaseModel
@@ -31,3 +32,29 @@ else:
 
 STOP_LOOP_TYPE = Literal["STOP_LOOP"]
 STOP_LOOP: STOP_LOOP_TYPE = "STOP_LOOP"  # Sentinel object to stop the loop
+
+
+class LogLevel(str, Enum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARN = "WARN"
+    ERROR = "ERROR"
+
+    @classmethod
+    def from_levelname(cls, levelname: str) -> "LogLevel":
+        levelname = levelname.upper()
+
+        if levelname == "DEBUG":
+            return cls.DEBUG
+
+        if levelname == "INFO":
+            return cls.INFO
+
+        if levelname in ["WARNING", "WARN"]:
+            return cls.WARN
+
+        if levelname == "ERROR":
+            return cls.ERROR
+
+        # fall back to INFO
+        return cls.INFO

hatchet_sdk/worker/runner/runner.py

@@ -166,22 +166,22 @@ class Runner:
             except Exception as e:
                 should_not_retry = isinstance(e, NonRetryableException)
 
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
 
                 # This except is coming from the application itself, so we want to send that to the Hatchet instance
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=should_not_retry,
                     )
                 )
 
-                log_with_level = logger.info if should_not_retry else logger.error
+                log_with_level = logger.info if should_not_retry else logger.exception
 
                 log_with_level(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -198,18 +198,18 @@ class Runner:
                     )
                 )
             except IllegalTaskOutputError as e:
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=False,
                     )
                 )
 
-                logger.error(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                logger.exception(
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -230,19 +230,19 @@ class Runner:
             try:
                 output = task.result()
             except Exception as e:
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
 
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=GROUP_KEY_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=False,
                     )
                 )
 
-                logger.error(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                logger.exception(
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -259,18 +259,18 @@ class Runner:
                     )
                 )
             except IllegalTaskOutputError as e:
-                exc = TaskRunError.from_exception(e)
+                exc = TaskRunError.from_exception(e, action.step_run_id)
                 self.event_queue.put(
                     ActionEvent(
                         action=action,
                         type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(),
+                        payload=exc.serialize(include_metadata=True),
                         should_not_retry=False,
                     )
                 )
 
-                logger.error(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize()}"
+                logger.exception(
+                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
                 )
 
                 return
@@ -280,12 +280,16 @@ class Runner:
         return inner_callback
 
     def thread_action_func(
-        self, ctx: Context, task: Task[TWorkflowInput, R], action: Action
+        self,
+        ctx: Context,
+        task: Task[TWorkflowInput, R],
+        action: Action,
+        dependencies: dict[str, Any],
     ) -> R:
         if action.step_run_id or action.get_group_key_run_id:
             self.threads[action.key] = current_thread()
 
-        return task.call(ctx)
+        return task.call(ctx, dependencies)
 
     # We wrap all actions in an async func
     async def async_wrapped_action_func(
@@ -300,9 +304,12 @@ class Runner:
         ctx_action_key.set(action.key)
         ctx_additional_metadata.set(action.additional_metadata)
 
+        dependencies = await task._unpack_dependencies(ctx)
+
         try:
             if task.is_async_function:
-                return await task.aio_call(ctx)
+                return await task.aio_call(ctx, dependencies)
+
             pfunc = functools.partial(
                 # we must copy the context vars to the new thread, as only asyncio natively supports
                 # contextvars
@@ -343,6 +350,7 @@ class Runner:
                 ctx,
                 task,
                 action,
+                dependencies,
             )
 
             loop = asyncio.get_event_loop()

hatchet_sdk/worker/runner/utils/capture_logs.py

@@ -16,7 +16,12 @@ from hatchet_sdk.runnables.contextvars import (
     ctx_worker_id,
     ctx_workflow_run_id,
 )
-from hatchet_sdk.utils.typing import STOP_LOOP, STOP_LOOP_TYPE, JSONSerializableMapping
+from hatchet_sdk.utils.typing import (
+    STOP_LOOP,
+    STOP_LOOP_TYPE,
+    JSONSerializableMapping,
+    LogLevel,
+)
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -67,6 +72,7 @@ def copy_context_vars(
 class LogRecord(BaseModel):
     message: str
     step_run_id: str
+    level: LogLevel
 
 
 class AsyncLogSender:
@@ -86,6 +92,7 @@ class AsyncLogSender:
                     self.event_client.log,
                     message=record.message,
                     step_run_id=record.step_run_id,
+                    level=record.level,
                 )
             except Exception:
                 logger.exception("failed to send log to Hatchet")
@@ -97,7 +104,7 @@ class AsyncLogSender:
             logger.warning("log queue is full, dropping log message")
 
 
-class CustomLogHandler(logging.StreamHandler):  # type: ignore[type-arg]
+class LogForwardingHandler(logging.StreamHandler):  # type: ignore[type-arg]
     def __init__(self, log_sender: AsyncLogSender, stream: StringIO):
         super().__init__(stream)
 
@@ -112,7 +119,13 @@ class CustomLogHandler(logging.StreamHandler):  # type: ignore[type-arg]
         if not step_run_id:
             return
 
-        self.log_sender.publish(LogRecord(message=log_entry, step_run_id=step_run_id))
+        self.log_sender.publish(
+            LogRecord(
+                message=log_entry,
+                step_run_id=step_run_id,
+                level=LogLevel.from_levelname(record.levelname),
+            )
+        )
 
 
 def capture_logs(
@@ -121,27 +134,27 @@ def capture_logs(
     @functools.wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
         log_stream = StringIO()
-        custom_handler = CustomLogHandler(log_sender, log_stream)
-        custom_handler.setLevel(logger.level)
+        log_forwarder = LogForwardingHandler(log_sender, log_stream)
+        log_forwarder.setLevel(logger.level)
 
         if logger.handlers:
             for handler in logger.handlers:
                 if handler.formatter:
-                    custom_handler.setFormatter(handler.formatter)
+                    log_forwarder.setFormatter(handler.formatter)
                     break
 
             for handler in logger.handlers:
                 for filter_obj in handler.filters:
-                    custom_handler.addFilter(filter_obj)
+                    log_forwarder.addFilter(filter_obj)
 
-        if not any(h for h in logger.handlers if isinstance(h, CustomLogHandler)):
-            logger.addHandler(custom_handler)
+        if not any(h for h in logger.handlers if isinstance(h, LogForwardingHandler)):
+            logger.addHandler(log_forwarder)
 
         try:
             result = await func(*args, **kwargs)
         finally:
-            custom_handler.flush()
-            logger.removeHandler(custom_handler)
+            log_forwarder.flush()
+            logger.removeHandler(log_forwarder)
             log_stream.close()
 
         return result

{hatchet_sdk-1.16.5.dist-info → hatchet_sdk-1.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.16.5
+Version: 1.17.0
 Summary: 
 License: MIT
 Author: Alexander Belanger
@@ -15,7 +15,6 @@ Provides-Extra: otel
 Requires-Dist: aiohttp (>=3.10.5,<4.0.0)
 Requires-Dist: aiohttp-retry (>=2.8.3,<3.0.0)
 Requires-Dist: aiostream (>=0.5.2,<0.6.0)
-Requires-Dist: cel-python (>=0.2.0,<0.3.0)
 Requires-Dist: grpcio (>=1.64.1,!=1.68.*) ; python_version < "3.13"
 Requires-Dist: grpcio (>=1.69.0) ; python_version >= "3.13"
 Requires-Dist: grpcio-tools (>=1.64.1,!=1.68.*) ; python_version < "3.13"

{hatchet_sdk-1.16.5.dist-info → hatchet_sdk-1.17.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-hatchet_sdk/__init__.py,sha256=r51t5nLruYORKSpxdMJ5jbub6sWVANyWM-VOw2QQKuw,10887
+hatchet_sdk/__init__.py,sha256=ng-IkoknD8Xbq1q8Wc42tEsO0OhD74MI9FPbBor9ut8,10911
 hatchet_sdk/client.py,sha256=s0-0WXGTyLkD-JOJl68bsaInDKOzDHSM5NCB0ic46lw,2502
 hatchet_sdk/clients/admin.py,sha256=Blx1OYhPGcdbUVCNq7n5jygjTy--8l_RYpjV-a8DRjw,17058
 hatchet_sdk/clients/dispatcher/action_listener.py,sha256=FeIYd8HZoYX_ELdeu--Nc6kTn9OfjL7Tr7WCs2EgJbc,13822
 hatchet_sdk/clients/dispatcher/dispatcher.py,sha256=1d4_4DYdFskqXjmHPHgZ-jBx1l9fQ1e0SMIweDL0VsE,8559
 hatchet_sdk/clients/event_ts.py,sha256=JVfxZ-OJ-xv7xJgPWAjv-g7ChwnkVwMDbYNVcAF-XnE,2121
-hatchet_sdk/clients/events.py,sha256=wE36_Wyb8BLywpuc8epRj7ZZDN9UCmztn6g3wdgRivM,8849
+hatchet_sdk/clients/events.py,sha256=fcoC7OhLmAKMyeXJMY-zhPPcr129em9XO-gGPh10BBg,8954
 hatchet_sdk/clients/listeners/durable_event_listener.py,sha256=55WbVQpm65ccVSQtqz-Z_4EI8Gig-7MzH5F9Arh-rb0,4166
 hatchet_sdk/clients/listeners/pooled_listener.py,sha256=mBx9XTQZuFStyvuM93QPyhjnF7qF2XzWfuUR7bniHt8,8512
 hatchet_sdk/clients/listeners/run_event_listener.py,sha256=CNXG5a_MUoYnNVmfrXkW1w3v6UnImyeUFXHQ96n4ULM,10222
@@ -261,7 +261,7 @@ hatchet_sdk/conditions.py,sha256=CnhpkXgVXM3wc0kAX8KZQA6tp8NFAbdzAN2xFbw7Hb0,452
 hatchet_sdk/config.py,sha256=9yXDCBfVW5AHosiSRWiEScSFSsm7Lx7wi0urNLC11Ck,5266
 hatchet_sdk/connection.py,sha256=XCBY9-UxaN3blakgZ59AhDpjb1ilLOOlmNNM6QaDtMM,2961
 hatchet_sdk/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hatchet_sdk/context/context.py,sha256=NZzFLu1hOZqsZNGSF8T_LrZOMfFDX-2DIyNMtZXs2ck,15359
+hatchet_sdk/context/context.py,sha256=KE-GsaosBar8USXSj1lkWHdsZXfXFf6tI9RwGTOF-aM,16278
 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
@@ -281,7 +281,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=DG-mS0wZiB-4Pnyr-BgY-LRrAEAdgP2nqQlIheU99t4,2646
+hatchet_sdk/exceptions.py,sha256=4NC_3CgJhZVF4RYJ6zAb2i4mGqFUL4TiKGSTz99bV-w,4656
 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
@@ -293,18 +293,18 @@ hatchet_sdk/features/scheduled.py,sha256=t7YA9CoJrzBhH82ChTSFWaTF_dyoC9i1O_wf9yw
 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=weSL5A_Ea61ryFtGBe2CST51z9aI3HCzW0dSSJ6G9wA,25984
+hatchet_sdk/hatchet.py,sha256=rEqakbTENR__bars1GM42d6RWrsgu8YzenvnEnkEd5E,26416
 hatchet_sdk/labels.py,sha256=nATgxWE3lFxRTnfISEpoIRLGbMfAZsHF4lZTuG4Mfic,182
 hatchet_sdk/logger.py,sha256=5uOr52T4mImSQm1QvWT8HvZFK5WfPNh3Y1cBQZRFgUQ,333
 hatchet_sdk/metadata.py,sha256=XkRbhnghJJGCdVvF-uzyGBcNaTqpeQ3uiQvNNP1wyBc,107
 hatchet_sdk/opentelemetry/instrumentor.py,sha256=7-OM_6Wu_EJaOVyYECNj7H50YqX6SkokQe1hGtU1rFY,27028
 hatchet_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hatchet_sdk/rate_limit.py,sha256=TwbCuggiZaWpYuo4mjVLlE-z1OfQ2mRBiVvCSaG3lv4,3919
+hatchet_sdk/rate_limit.py,sha256=ptFvHJU9rCzxfcITZEnRkKtJM-SY12WP84FzBwCKAPE,3277
 hatchet_sdk/runnables/action.py,sha256=zrVHpyzIQ9XZgWwY69b_6uhZd53An4trRoLd9b3os5E,4384
 hatchet_sdk/runnables/contextvars.py,sha256=jHrrewUlFPAT9f2u3VCsuSlDBtBoagEUtUzJOSmm4yk,1118
-hatchet_sdk/runnables/task.py,sha256=-5AeToJqIbpgGeyrol5VJaFGND4l_UY8k9VIhrUBXaw,12796
+hatchet_sdk/runnables/task.py,sha256=JsiDBkYQVJodyqtNDT9z8Pwz3ePL8GhY0Z1-ptPw9ms,16030
 hatchet_sdk/runnables/types.py,sha256=M23xSMTBPl12CXCCXZ0wbnqZ_sePB6CJKtOdipiNDlg,4362
-hatchet_sdk/runnables/workflow.py,sha256=_F5XIeokfQxMgrFtVjdM3ArtCwfKj3u51dinA7ouyWI,57513
+hatchet_sdk/runnables/workflow.py,sha256=Nm71LrY_EcPJUrlzRuBh6sp7bv-pMrt0gQgZNftue9g,57848
 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
@@ -313,7 +313,7 @@ hatchet_sdk/utils/opentelemetry.py,sha256=64TVwCLrUzEmcL2BUNPV_QubfiR5jajOZtVeGY
 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=FgYnZyJSoRjNVFodxlI9gn0X8ST1KFed7xfUynIxa2U,978
+hatchet_sdk/utils/typing.py,sha256=zyRsfF-HO_aVhNx_vun-BRCbMWYDBps8aV0NczGUcho,1534
 hatchet_sdk/v0/__init__.py,sha256=r3Q7l2RsLgdIkK2jjiz7-JJpD1T_Zy--Oa9MN5n_yEs,9654
 hatchet_sdk/v0/client.py,sha256=G1RDZln9Og7tRQulogXkZw8TsVlx7f0VvmtFI_VAe6E,3495
 hatchet_sdk/v0/clients/admin.py,sha256=0ZsBPLZ5ktn_oC2VZsJqqcqr2m8TnU07ogml46p_X58,18065
@@ -538,11 +538,11 @@ hatchet_sdk/v0/workflow_run.py,sha256=jsEZprXshrSV7i_TtL5uoCL03D18zQ3NeJCq7mp97D
 hatchet_sdk/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatchet_sdk/worker/action_listener_process.py,sha256=CzXen-7tFG_rryvM2xWV2_KMUFC2-i_Ts643TB_Urd8,12878
 hatchet_sdk/worker/runner/run_loop_manager.py,sha256=BcdfxSvZdrxbeTZSUASwCTMKJe6pwLorHVKPTprkM2k,4176
-hatchet_sdk/worker/runner/runner.py,sha256=L5J_dbwpz2P0rbDzpxW1udByQJHii28KEvzx-1LxB_8,22406
-hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=FBEcPTi6cxFsGPER51k-xeMUzVJhLIAq7NyKTHCM5-E,4386
+hatchet_sdk/worker/runner/runner.py,sha256=QULD00hEyW2dcHCcH46C1k7mxr5nHEwtusyAs33VOO0,22857
+hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=Gpzcs1JVqZE0spFztyjcbcUTjDCrdIBI9c_POVhSIvk,4616
 hatchet_sdk/worker/worker.py,sha256=9EiESMMcS7voa4cAnmnHMx4rC-pqaTmP74bcTbFPqfQ,16435
 hatchet_sdk/workflow_run.py,sha256=KcylcqRwKADtnzOTjoiVr1vdr7qTZFtDeD5aRS6A4Y8,2823
-hatchet_sdk-1.16.5.dist-info/METADATA,sha256=UijjCLHKfTjcYSAAmG-cy0awxxfNPnuqlls_66QPWgc,3628
-hatchet_sdk-1.16.5.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-hatchet_sdk-1.16.5.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
-hatchet_sdk-1.16.5.dist-info/RECORD,,
+hatchet_sdk-1.17.0.dist-info/METADATA,sha256=_ChzeGYdEXj9NRkokdcAU4aME768nOI09kILBnz2YUE,3585
+hatchet_sdk-1.17.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+hatchet_sdk-1.17.0.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
+hatchet_sdk-1.17.0.dist-info/RECORD,,