hatchet-sdk 1.11.1__py3-none-any.whl → 1.12.1__py3-none-any.whl

hatchet_sdk/hatchet.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 from datetime import timedelta
+from functools import cached_property
 from typing import Any, Callable, Type, Union, cast, overload
 
 from hatchet_sdk import Context, DurableContext
@@ -8,6 +9,7 @@ from hatchet_sdk.client import Client
 from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
 from hatchet_sdk.clients.events import EventClient
 from hatchet_sdk.clients.listeners.run_event_listener import RunEventListenerClient
+from hatchet_sdk.clients.rest.models.tenant_version import TenantVersion
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.features.cron import CronClient
 from hatchet_sdk.features.filters import FiltersClient
@@ -21,9 +23,9 @@ from hatchet_sdk.features.workflows import WorkflowsClient
 from hatchet_sdk.labels import DesiredWorkerLabel
 from hatchet_sdk.logger import logger
 from hatchet_sdk.rate_limit import RateLimit
-from hatchet_sdk.runnables.standalone import Standalone
 from hatchet_sdk.runnables.types import (
     ConcurrencyExpression,
+    DefaultFilter,
     EmptyModel,
     R,
     StickyStrategy,
@@ -31,7 +33,7 @@ from hatchet_sdk.runnables.types import (
     TWorkflowInput,
     WorkflowConfig,
 )
-from hatchet_sdk.runnables.workflow import BaseWorkflow, Workflow
+from hatchet_sdk.runnables.workflow import BaseWorkflow, Standalone, Workflow
 from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import CoroutineLike
 from hatchet_sdk.worker.worker import LifespanFn, Worker
@@ -58,6 +60,11 @@ class Hatchet:
             client if client else Client(config=config or ClientConfig(), debug=debug)
         )
 
+        if self.tenant_engine_version != TenantVersion.V1:
+            logger.warning(
+                "🚨⚠️‼️ YOU ARE USING A V0 ENGINE WITH A V1 SDK, WHICH IS NOT SUPPORTED. PLEASE UPGRADE YOUR ENGINE TO V1.🚨⚠️‼️"
+            )
+
     @property
     def cron(self) -> CronClient:
         """
@@ -156,6 +163,19 @@ class Hatchet:
         """
         return self._client.config.namespace
 
+    @cached_property
+    def tenant_engine_version(self) -> TenantVersion:
+        """
+        Get the version of the Hatchet engine running in your tenant.
+        """
+        try:
+            return self._client.tenant.get().version
+        except Exception:
+            ## Nothing we can do here - if this fails, it's probably
+            ## because they don't have this endpoint yet, so we need to just
+            ## assume V1 to swallow the warning.
+            return TenantVersion.V1
+
     def worker(
         self,
         name: str,
@@ -214,6 +234,7 @@ class Hatchet:
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         task_defaults: TaskDefaults = TaskDefaults(),
+        default_filters: list[DefaultFilter] = [],
     ) -> Workflow[EmptyModel]: ...
 
     @overload
@@ -230,6 +251,7 @@ class Hatchet:
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         task_defaults: TaskDefaults = TaskDefaults(),
+        default_filters: list[DefaultFilter] = [],
     ) -> Workflow[TWorkflowInput]: ...
 
     def workflow(
@@ -245,6 +267,7 @@ class Hatchet:
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         task_defaults: TaskDefaults = TaskDefaults(),
+        default_filters: list[DefaultFilter] = [],
     ) -> Workflow[EmptyModel] | Workflow[TWorkflowInput]:
         """
         Define a Hatchet workflow, which can then declare `task`s and be `run`, `schedule`d, and so on.
@@ -269,6 +292,8 @@ class Hatchet:
 
         :param task_defaults: A `TaskDefaults` object controlling the default task settings for this workflow.
 
+        :param default_filters: A list of filters to create with the workflow is created. Note that this is a helper to allow you to create filters "declaratively" without needing to make a separate API call once the workflow is created to create them.
+
         :returns: The created `Workflow` object, which can be used to declare tasks, run the workflow, and so on.
         """
 
@@ -285,6 +310,7 @@ class Hatchet:
                 or cast(Type[TWorkflowInput], EmptyModel),
                 task_defaults=task_defaults,
                 default_priority=default_priority,
+                default_filters=default_filters,
             ),
             self,
         )
@@ -309,6 +335,7 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
+        default_filters: list[DefaultFilter] = [],
     ) -> Callable[
         [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
@@ -334,6 +361,7 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
+        default_filters: list[DefaultFilter] = [],
     ) -> Callable[
         [Callable[[TWorkflowInput, Context], R | CoroutineLike[R]]],
         Standalone[TWorkflowInput, R],
@@ -358,6 +386,7 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
+        default_filters: list[DefaultFilter] = [],
     ) -> (
         Callable[
             [Callable[[EmptyModel, Context], R | CoroutineLike[R]]],
@@ -403,6 +432,8 @@ class Hatchet:
 
         :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
 
+        :param default_filters: A list of filters to create with the task is created. Note that this is a helper to allow you to create filters "declaratively" without needing to make a separate API call once the task is created to create them.
+
         :returns: A decorator which creates a `Standalone` task object.
         """
 
@@ -419,10 +450,10 @@ class Hatchet:
                     on_events=on_events,
                     on_crons=on_crons,
                     sticky=sticky,
-                    concurrency=concurrency,
                     default_priority=default_priority,
                     input_validator=input_validator
                     or cast(Type[TWorkflowInput], EmptyModel),
+                    default_filters=default_filters,
                 ),
                 self,
             )
@@ -468,7 +499,7 @@ class Hatchet:
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
-        concurrency: ConcurrencyExpression | None = None,
+        concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
@@ -476,6 +507,7 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
+        default_filters: list[DefaultFilter] = [],
     ) -> Callable[
         [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
         Standalone[EmptyModel, R],
@@ -493,7 +525,7 @@ class Hatchet:
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
-        concurrency: ConcurrencyExpression | None = None,
+        concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
@@ -501,6 +533,7 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
+        default_filters: list[DefaultFilter] = [],
     ) -> Callable[
         [Callable[[TWorkflowInput, DurableContext], R | CoroutineLike[R]]],
         Standalone[TWorkflowInput, R],
@@ -517,7 +550,7 @@ class Hatchet:
         version: str | None = None,
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
-        concurrency: ConcurrencyExpression | None = None,
+        concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
         schedule_timeout: Duration = timedelta(minutes=5),
         execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
@@ -525,6 +558,7 @@ class Hatchet:
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
         backoff_factor: float | None = None,
         backoff_max_seconds: int | None = None,
+        default_filters: list[DefaultFilter] = [],
     ) -> (
         Callable[
             [Callable[[EmptyModel, DurableContext], R | CoroutineLike[R]]],
@@ -570,6 +604,8 @@ class Hatchet:
 
         :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
 
+        :param default_filters: A list of filters to create with the task is created. Note that this is a helper to allow you to create filters "declaratively" without needing to make a separate API call once the task is created to create them.
+
         :returns: A decorator which creates a `Standalone` task object.
         """
 
@@ -585,14 +621,21 @@ class Hatchet:
                     on_events=on_events,
                     on_crons=on_crons,
                     sticky=sticky,
-                    concurrency=concurrency,
                     input_validator=input_validator
                     or cast(Type[TWorkflowInput], EmptyModel),
                     default_priority=default_priority,
+                    default_filters=default_filters,
                 ),
                 self,
             )
 
+            if isinstance(concurrency, list):
+                _concurrency = concurrency
+            elif isinstance(concurrency, ConcurrencyExpression):
+                _concurrency = [concurrency]
+            else:
+                _concurrency = []
+
             task_wrapper = workflow.durable_task(
                 name=inferred_name,
                 schedule_timeout=schedule_timeout,
@@ -603,7 +646,7 @@ class Hatchet:
                 desired_worker_labels=desired_worker_labels,
                 backoff_factor=backoff_factor,
                 backoff_max_seconds=backoff_max_seconds,
-                concurrency=[concurrency] if concurrency else [],
+                concurrency=_concurrency,
             )
 
             created_task = task_wrapper(func)

hatchet_sdk/runnables/action.py

@@ -41,7 +41,7 @@ class ActionPayload(BaseModel):
 
     @model_validator(mode="after")
     def validate_filter_payload(self) -> "ActionPayload":
-        self.filter_payload = self.triggers.get("filter_payload", {})
+        self.filter_payload = self.triggers.get("filter_payload", {}) or {}
 
         return self
 

hatchet_sdk/runnables/types.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 from enum import Enum
 from typing import Any, Callable, ParamSpec, Type, TypeGuard, TypeVar, Union
 
@@ -6,6 +7,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.contracts.v1.workflows_pb2 import Concurrency
+from hatchet_sdk.contracts.v1.workflows_pb2 import DefaultFilter as DefaultFilterProto
 from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import AwaitableLike, JSONSerializableMapping
 
@@ -65,6 +67,21 @@ class TaskDefaults(BaseModel):
     backoff_max_seconds: int | None = None
 
 
+class DefaultFilter(BaseModel):
+    expression: str
+    scope: str
+    payload: JSONSerializableMapping = Field(default_factory=dict)
+
+    def to_proto(self) -> DefaultFilterProto:
+        payload_json = json.dumps(self.payload, default=str)
+
+        return DefaultFilterProto(
+            expression=self.expression,
+            scope=self.scope,
+            payload=payload_json,
+        )
+
+
 class WorkflowConfig(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
 
@@ -79,6 +96,7 @@ class WorkflowConfig(BaseModel):
     default_priority: int | None = None
 
     task_defaults: TaskDefaults = TaskDefaults()
+    default_filters: list[DefaultFilter] = Field(default_factory=list)
 
 
 class StepType(str, Enum):
@@ -93,13 +111,13 @@ TaskFunc = Union[AsyncFunc[TWorkflowInput, R], SyncFunc[TWorkflowInput, R]]
 
 
 def is_async_fn(
-    fn: TaskFunc[TWorkflowInput, R]
+    fn: TaskFunc[TWorkflowInput, R],
 ) -> TypeGuard[AsyncFunc[TWorkflowInput, R]]:
     return asyncio.iscoroutinefunction(fn)
 
 
 def is_sync_fn(
-    fn: TaskFunc[TWorkflowInput, R]
+    fn: TaskFunc[TWorkflowInput, R],
 ) -> TypeGuard[SyncFunc[TWorkflowInput, R]]:
     return not asyncio.iscoroutinefunction(fn)
 
@@ -112,12 +130,12 @@ DurableTaskFunc = Union[
 
 
 def is_durable_async_fn(
-    fn: Callable[..., Any]
+    fn: Callable[..., Any],
 ) -> TypeGuard[DurableAsyncFunc[TWorkflowInput, R]]:
     return asyncio.iscoroutinefunction(fn)
 
 
 def is_durable_sync_fn(
-    fn: DurableTaskFunc[TWorkflowInput, R]
+    fn: DurableTaskFunc[TWorkflowInput, R],
 ) -> TypeGuard[DurableSyncFunc[TWorkflowInput, R]]:
     return not asyncio.iscoroutinefunction(fn)