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

hatchet_sdk/rate_limit.py

@@ -1,13 +1,126 @@
 from dataclasses import dataclass
+from typing import Union
 
+from celpy import CELEvalError, Environment
 
-@dataclass
-class RateLimit:
-    key: str
-    units: int
+from hatchet_sdk.contracts.workflows_pb2 import CreateStepRateLimit
+
+
+def validate_cel_expression(expr: str) -> bool:
+    env = Environment()
+    try:
+        env.compile(expr)
+        return True
+    except CELEvalError:
+        return False
 
 
 class RateLimitDuration:
     SECOND = "SECOND"
     MINUTE = "MINUTE"
     HOUR = "HOUR"
+    DAY = "DAY"
+    WEEK = "WEEK"
+    MONTH = "MONTH"
+    YEAR = "YEAR"
+
+
+@dataclass
+class RateLimit:
+    """
+    Represents a rate limit configuration for a step in a workflow.
+
+    This class allows for both static and dynamic rate limiting based on various parameters.
+    It supports both simple integer values and Common Expression Language (CEL) expressions
+    for dynamic evaluation.
+
+    Attributes:
+        static_key (str, optional): A static key for rate limiting.
+        dynamic_key (str, optional): A CEL expression for dynamic key evaluation.
+        units (int or str, default=1): The number of units or a CEL expression for dynamic unit calculation.
+        limit (int or str, optional): The rate limit value or a CEL expression for dynamic limit calculation.
+        duration (str, default=RateLimitDuration.MINUTE): The window duration of the rate limit.
+        key (str, optional): Deprecated. Use static_key instead.
+
+    Usage:
+        1. Static rate limit:
+           rate_limit = RateLimit(static_key="external-api", units=100)
+           > NOTE: if you want to use a static key, you must first put the rate limit: hatchet.admin.put_rate_limit("external-api", 200, RateLimitDuration.SECOND)
+
+        2. Dynamic rate limit with CEL expressions:
+           rate_limit = RateLimit(
+               dynamic_key="input.user_id",
+               units="input.units",
+               limit="input.limit * input.user_tier"
+           )
+
+    Note:
+        - Either static_key or dynamic_key must be set, but not both.
+        - When using dynamic_key, limit must also be set.
+        - CEL expressions are validated upon instantiation.
+
+    Raises:
+        ValueError: If invalid combinations of attributes are provided or if CEL expressions are invalid.
+        DeprecationWarning: If the deprecated 'key' attribute is used.
+    """
+
+    key: Union[str, None] = None
+    static_key: Union[str, None] = None
+    dynamic_key: Union[str, None] = None
+    units: Union[int, str] = 1
+    limit: Union[int, str, None] = None
+    duration: RateLimitDuration = RateLimitDuration.MINUTE
+
+    _req: CreateStepRateLimit = None
+
+    def __post_init__(self):
+        # juggle the key and key_expr fields
+        key = self.static_key
+        key_expression = self.dynamic_key
+
+        if self.key is not None:
+            DeprecationWarning(
+                "key is deprecated and will be removed in a future release, please use static_key instead"
+            )
+            key = self.key
+
+        if key_expression is not None:
+            if key is not None:
+                raise ValueError("Cannot have both static key and dynamic key set")
+
+            key = key_expression
+            if not validate_cel_expression(key_expression):
+                raise ValueError(f"Invalid CEL expression: {key_expression}")
+
+        # juggle the units and units_expr fields
+        units = None
+        units_expression = None
+        if isinstance(self.units, int):
+            units = self.units
+        else:
+            if not validate_cel_expression(self.units):
+                raise ValueError(f"Invalid CEL expression: {self.units}")
+            units_expression = self.units
+
+        # juggle the limit and limit_expr fields
+        limit_expression = None
+
+        if self.limit:
+            if isinstance(self.limit, int):
+                limit_expression = f"{self.limit}"
+            else:
+                if not validate_cel_expression(self.limit):
+                    raise ValueError(f"Invalid CEL expression: {self.limit}")
+                limit_expression = self.limit
+
+        if key_expression is not None and limit_expression is None:
+            raise ValueError("CEL based keys requires limit to be set")
+
+        self._req = CreateStepRateLimit(
+            key=key,
+            key_expr=key_expression,
+            units=units,
+            units_expr=units_expression,
+            limit_values_expr=limit_expression,
+            duration=self.duration,
+        )

hatchet_sdk/utils/aio_utils.py

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

hatchet_sdk/utils/typing.py

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

hatchet_sdk/v2/callable.py

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

hatchet_sdk/v2/concurrency.py

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

hatchet_sdk/v2/hatchet.py

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

hatchet_sdk/worker/runner/runner.py

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

hatchet_sdk/worker/worker.py

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

hatchet_sdk/workflow.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 0.42.2
+Version: 0.42.4
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.12
 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.1.5,<0.2.0)
 Requires-Dist: grpcio (>=1.64.1,<2.0.0)
 Requires-Dist: grpcio-tools (>=1.60.0,<2.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)