hatchet-sdk 1.16.5__tar.gz → 1.17.0__tar.gz

{hatchet_sdk-1.16.5 → hatchet_sdk-1.17.0}/PKG-INFO

@@ -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 → hatchet_sdk-1.17.0}/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-1.16.5 → hatchet_sdk-1.17.0}/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-1.16.5 → hatchet_sdk-1.17.0}/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-1.16.5 → hatchet_sdk-1.17.0}/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-1.16.5 → hatchet_sdk-1.17.0}/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-1.16.5 → hatchet_sdk-1.17.0}/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-1.16.5 → hatchet_sdk-1.17.0}/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)