hatchet-sdk 1.2.6__py3-none-any.whl → 1.3.0__py3-none-any.whl

hatchet_sdk/runnables/standalone.py

@@ -11,7 +11,6 @@ from hatchet_sdk.contracts.workflows_pb2 import WorkflowVersion
 from hatchet_sdk.runnables.task import Task
 from hatchet_sdk.runnables.types import EmptyModel, R, TWorkflowInput
 from hatchet_sdk.runnables.workflow import BaseWorkflow, Workflow
-from hatchet_sdk.utils.aio import run_async_from_sync
 from hatchet_sdk.utils.typing import JSONSerializableMapping, is_basemodel_subclass
 from hatchet_sdk.workflow_run import WorkflowRunRef
 
@@ -31,11 +30,15 @@ class TaskRunRef(Generic[TWorkflowInput, R]):
         return self.workflow_run_id
 
     async def aio_result(self) -> R:
-        result = await self._wrr.workflow_listener.aio_result(self._wrr.workflow_run_id)
+        result = await self._wrr.workflow_run_listener.aio_result(
+            self._wrr.workflow_run_id
+        )
         return self._s._extract_result(result)
 
     def result(self) -> R:
-        return run_async_from_sync(self.aio_result)
+        result = self._wrr.result()
+
+        return self._s._extract_result(result)
 
 
 class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
@@ -129,7 +132,7 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
     def schedule(
         self,
         run_at: datetime,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
         return self._workflow.schedule(
@@ -141,7 +144,7 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
     async def aio_schedule(
         self,
         run_at: datetime,
-        input: TWorkflowInput,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
         return await self._workflow.aio_schedule(
@@ -154,8 +157,8 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         self,
         cron_name: str,
         expression: str,
-        input: TWorkflowInput,
-        additional_metadata: JSONSerializableMapping,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
+        additional_metadata: JSONSerializableMapping = {},
     ) -> CronWorkflows:
         return self._workflow.create_cron(
             cron_name=cron_name,
@@ -168,8 +171,8 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         self,
         cron_name: str,
         expression: str,
-        input: TWorkflowInput,
-        additional_metadata: JSONSerializableMapping,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
+        additional_metadata: JSONSerializableMapping = {},
     ) -> CronWorkflows:
         return await self._workflow.aio_create_cron(
             cron_name=cron_name,

hatchet_sdk/runnables/task.py

@@ -10,7 +10,9 @@ from typing import (
 )
 
 from hatchet_sdk.context.context import Context, DurableContext
+from hatchet_sdk.contracts.v1.shared.condition_pb2 import TaskConditions
 from hatchet_sdk.contracts.v1.workflows_pb2 import (
+    CreateTaskOpts,
     CreateTaskRateLimit,
     DesiredWorkerLabels,
 )
@@ -25,8 +27,15 @@ from hatchet_sdk.runnables.types import (
     is_durable_sync_fn,
     is_sync_fn,
 )
-from hatchet_sdk.utils.timedelta_to_expression import Duration
-from hatchet_sdk.waits import Condition, OrGroup
+from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
+from hatchet_sdk.waits import (
+    Action,
+    Condition,
+    OrGroup,
+    ParentCondition,
+    SleepCondition,
+    UserEventCondition,
+)
 
 if TYPE_CHECKING:
     from hatchet_sdk.runnables.workflow import Workflow
@@ -142,3 +151,58 @@ class Task(Generic[TWorkflowInput, R]):
             return await self.fn(workflow_input, cast(Context, ctx))  # type: ignore
 
         raise TypeError(f"{self.name} is not an async function. Use `call` instead.")
+
+    def to_proto(self, service_name: str) -> CreateTaskOpts:
+        return CreateTaskOpts(
+            readable_id=self.name,
+            action=service_name + ":" + self.name,
+            timeout=timedelta_to_expr(self.execution_timeout),
+            inputs="{}",
+            parents=[p.name for p in self.parents],
+            retries=self.retries,
+            rate_limits=self.rate_limits,
+            worker_labels=self.desired_worker_labels,
+            backoff_factor=self.backoff_factor,
+            backoff_max_seconds=self.backoff_max_seconds,
+            concurrency=[t.to_proto() for t in self.concurrency],
+            conditions=self._conditions_to_proto(),
+            schedule_timeout=timedelta_to_expr(self.schedule_timeout),
+        )
+
+    def _assign_action(self, condition: Condition, action: Action) -> Condition:
+        condition.base.action = action
+
+        return condition
+
+    def _conditions_to_proto(self) -> TaskConditions:
+        wait_for_conditions = [
+            self._assign_action(w, Action.QUEUE) for w in self.wait_for
+        ]
+
+        cancel_if_conditions = [
+            self._assign_action(c, Action.CANCEL) for c in self.cancel_if
+        ]
+        skip_if_conditions = [self._assign_action(s, Action.SKIP) for s in self.skip_if]
+
+        conditions = wait_for_conditions + cancel_if_conditions + skip_if_conditions
+
+        if len({c.base.readable_data_key for c in conditions}) != len(
+            [c.base.readable_data_key for c in conditions]
+        ):
+            raise ValueError("Conditions must have unique readable data keys.")
+
+        user_events = [
+            c.to_proto() for c in conditions if isinstance(c, UserEventCondition)
+        ]
+        parent_overrides = [
+            c.to_proto() for c in conditions if isinstance(c, ParentCondition)
+        ]
+        sleep_conditions = [
+            c.to_proto() for c in conditions if isinstance(c, SleepCondition)
+        ]
+
+        return TaskConditions(
+            parent_override_conditions=parent_overrides,
+            sleep_conditions=sleep_conditions,
+            user_event_conditions=user_events,
+        )

hatchet_sdk/runnables/types.py

@@ -6,6 +6,7 @@ from typing import Any, Awaitable, Callable, ParamSpec, Type, TypeGuard, TypeVar
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, model_validator
 
 from hatchet_sdk.context.context import Context, DurableContext
+from hatchet_sdk.contracts.v1.workflows_pb2 import Concurrency
 from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
@@ -52,6 +53,13 @@ class ConcurrencyExpression(BaseModel):
     max_runs: int
     limit_strategy: ConcurrencyLimitStrategy
 
+    def to_proto(self) -> Concurrency:
+        return Concurrency(
+            expression=self.expression,
+            max_runs=self.max_runs,
+            limit_strategy=self.limit_strategy,
+        )
+
 
 TWorkflowInput = TypeVar("TWorkflowInput", bound=BaseModel)
 

hatchet_sdk/runnables/workflow.py

@@ -1,6 +1,6 @@
 import asyncio
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, Generic, cast
 
 from google.protobuf import timestamp_pb2
 from pydantic import BaseModel
@@ -12,10 +12,7 @@ from hatchet_sdk.clients.admin import (
 )
 from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
 from hatchet_sdk.context.context import Context, DurableContext
-from hatchet_sdk.contracts.v1.shared.condition_pb2 import TaskConditions
 from hatchet_sdk.contracts.v1.workflows_pb2 import (
-    Concurrency,
-    CreateTaskOpts,
     CreateWorkflowVersionRequest,
     DesiredWorkerLabels,
 )
@@ -36,16 +33,9 @@ from hatchet_sdk.runnables.types import (
     WorkflowConfig,
 )
 from hatchet_sdk.utils.proto_enums import convert_python_enum_to_proto
-from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
+from hatchet_sdk.utils.timedelta_to_expression import Duration
 from hatchet_sdk.utils.typing import JSONSerializableMapping
-from hatchet_sdk.waits import (
-    Action,
-    Condition,
-    OrGroup,
-    ParentCondition,
-    SleepCondition,
-    UserEventCondition,
-)
+from hatchet_sdk.waits import Condition, OrGroup
 from hatchet_sdk.workflow_run import WorkflowRunRef
 
 if TYPE_CHECKING:
@@ -78,16 +68,12 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         self._on_success_task: Task[TWorkflowInput, Any] | None = None
         self.client = client
 
-    def _get_service_name(self, namespace: str) -> str:
-        return f"{namespace}{self.config.name.lower()}"
-
-    def _create_action_name(
-        self, namespace: str, step: Task[TWorkflowInput, Any]
-    ) -> str:
-        return self._get_service_name(namespace) + ":" + step.name
+    @property
+    def service_name(self) -> str:
+        return f"{self.client.config.namespace}{self.config.name.lower()}"
 
-    def _get_name(self, namespace: str) -> str:
-        return namespace + self.config.name
+    def _create_action_name(self, step: Task[TWorkflowInput, Any]) -> str:
+        return self.service_name + ":" + step.name
 
     def _raise_for_invalid_concurrency(
         self, concurrency: ConcurrencyExpression
@@ -106,58 +92,6 @@ class BaseWorkflow(Generic[TWorkflowInput]):
 
         return True
 
-    @overload
-    def _concurrency_to_proto(self, concurrency: None) -> None: ...
-
-    @overload
-    def _concurrency_to_proto(
-        self, concurrency: ConcurrencyExpression
-    ) -> Concurrency: ...
-
-    def _concurrency_to_proto(
-        self, concurrency: ConcurrencyExpression | None
-    ) -> Concurrency | None:
-        if not concurrency:
-            return None
-
-        self._raise_for_invalid_concurrency(concurrency)
-
-        return Concurrency(
-            expression=concurrency.expression,
-            max_runs=concurrency.max_runs,
-            limit_strategy=concurrency.limit_strategy,
-        )
-
-    @overload
-    def _validate_task(
-        self, task: "Task[TWorkflowInput, R]", service_name: str
-    ) -> CreateTaskOpts: ...
-
-    @overload
-    def _validate_task(self, task: None, service_name: str) -> None: ...
-
-    def _validate_task(
-        self, task: Union["Task[TWorkflowInput, R]", None], service_name: str
-    ) -> CreateTaskOpts | None:
-        if not task:
-            return None
-
-        return CreateTaskOpts(
-            readable_id=task.name,
-            action=service_name + ":" + task.name,
-            timeout=timedelta_to_expr(task.execution_timeout),
-            inputs="{}",
-            parents=[p.name for p in task.parents],
-            retries=task.retries,
-            rate_limits=task.rate_limits,
-            worker_labels=task.desired_worker_labels,
-            backoff_factor=task.backoff_factor,
-            backoff_max_seconds=task.backoff_max_seconds,
-            concurrency=[self._concurrency_to_proto(t) for t in task.concurrency],
-            conditions=self._conditions_to_proto(task),
-            schedule_timeout=timedelta_to_expr(task.schedule_timeout),
-        )
-
     def _validate_priority(self, default_priority: int | None) -> int | None:
         validated_priority = (
             max(1, min(3, default_priority)) if default_priority else None
@@ -169,51 +103,14 @@ class BaseWorkflow(Generic[TWorkflowInput]):
 
         return validated_priority
 
-    def _assign_action(self, condition: Condition, action: Action) -> Condition:
-        condition.base.action = action
-
-        return condition
-
-    def _conditions_to_proto(self, task: Task[TWorkflowInput, Any]) -> TaskConditions:
-        wait_for_conditions = [
-            self._assign_action(w, Action.QUEUE) for w in task.wait_for
-        ]
-
-        cancel_if_conditions = [
-            self._assign_action(c, Action.CANCEL) for c in task.cancel_if
-        ]
-        skip_if_conditions = [self._assign_action(s, Action.SKIP) for s in task.skip_if]
-
-        conditions = wait_for_conditions + cancel_if_conditions + skip_if_conditions
-
-        if len({c.base.readable_data_key for c in conditions}) != len(
-            [c.base.readable_data_key for c in conditions]
-        ):
-            raise ValueError("Conditions must have unique readable data keys.")
-
-        user_events = [
-            c.to_pb() for c in conditions if isinstance(c, UserEventCondition)
-        ]
-        parent_overrides = [
-            c.to_pb() for c in conditions if isinstance(c, ParentCondition)
-        ]
-        sleep_conditions = [
-            c.to_pb() for c in conditions if isinstance(c, SleepCondition)
-        ]
-
-        return TaskConditions(
-            parent_override_conditions=parent_overrides,
-            sleep_conditions=sleep_conditions,
-            user_event_conditions=user_events,
-        )
-
     def _is_leaf_task(self, task: Task[TWorkflowInput, Any]) -> bool:
         return not any(task in t.parents for t in self.tasks if task != t)
 
-    def _get_create_opts(self, namespace: str) -> CreateWorkflowVersionRequest:
-        service_name = self._get_service_name(namespace)
+    def to_proto(self) -> CreateWorkflowVersionRequest:
+        namespace = self.client.config.namespace
+        service_name = self.service_name
 
-        name = self._get_name(namespace)
+        name = self.name
         event_triggers = [namespace + event for event in self.config.on_events]
 
         if self._on_success_task:
@@ -223,10 +120,12 @@ class BaseWorkflow(Generic[TWorkflowInput]):
                 if task.type == StepType.DEFAULT and self._is_leaf_task(task)
             ]
 
-        on_success_task = self._validate_task(self._on_success_task, service_name)
+        on_success_task = (
+            t.to_proto(service_name) if (t := self._on_success_task) else None
+        )
 
         tasks = [
-            self._validate_task(task, service_name)
+            task.to_proto(service_name)
             for task in self.tasks
             if task.type == StepType.DEFAULT
         ]
@@ -234,7 +133,9 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         if on_success_task:
             tasks += [on_success_task]
 
-        on_failure_task = self._validate_task(self._on_failure_task, service_name)
+        on_failure_task = (
+            t.to_proto(service_name) if (t := self._on_failure_task) else None
+        )
 
         return CreateWorkflowVersionRequest(
             name=name,
@@ -243,7 +144,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
             event_triggers=event_triggers,
             cron_triggers=self.config.on_crons,
             tasks=tasks,
-            concurrency=self._concurrency_to_proto(self.config.concurrency),
+            concurrency=(c.to_proto() if (c := self.config.concurrency) else None),
             ## TODO: Fix this
             cron_input=None,
             on_failure_task=on_failure_task,
@@ -274,11 +175,11 @@ class BaseWorkflow(Generic[TWorkflowInput]):
 
     @property
     def name(self) -> str:
-        return self._get_name(self.client.config.namespace)
+        return self.client.config.namespace + self.config.name
 
     def create_bulk_run_item(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         key: str | None = None,
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunTriggerConfig:
@@ -394,7 +295,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     def schedule(
         self,
         run_at: datetime,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
         return self.client._client.admin.schedule_workflow(
@@ -407,7 +308,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     async def aio_schedule(
         self,
         run_at: datetime,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
         return await self.client._client.admin.aio_schedule_workflow(
@@ -421,7 +322,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         cron_name: str,
         expression: str,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         additional_metadata: JSONSerializableMapping = {},
     ) -> CronWorkflows:
         return self.client.cron.create(
@@ -436,7 +337,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         cron_name: str,
         expression: str,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         additional_metadata: JSONSerializableMapping = {},
     ) -> CronWorkflows:
         return await self.client.cron.aio_create(

hatchet_sdk/waits.py

@@ -37,7 +37,7 @@ class BaseCondition(BaseModel):
     or_group_id: str = Field(default_factory=generate_or_group_id)
     expression: str | None = None
 
-    def to_pb(self) -> BaseMatchCondition:
+    def to_proto(self) -> BaseMatchCondition:
         return BaseMatchCondition(
             readable_data_key=self.readable_data_key,
             action=convert_python_enum_to_proto(self.action, ProtoAction),  # type: ignore[arg-type]
@@ -51,7 +51,7 @@ class Condition(ABC):
         self.base = base
 
     @abstractmethod
-    def to_pb(
+    def to_proto(
         self,
     ) -> UserEventMatchCondition | ParentOverrideMatchCondition | SleepMatchCondition:
         pass
@@ -67,9 +67,9 @@ class SleepCondition(Condition):
 
         self.duration = duration
 
-    def to_pb(self) -> SleepMatchCondition:
+    def to_proto(self) -> SleepMatchCondition:
         return SleepMatchCondition(
-            base=self.base.to_pb(),
+            base=self.base.to_proto(),
             sleep_for=timedelta_to_expr(self.duration),
         )
 
@@ -86,9 +86,9 @@ class UserEventCondition(Condition):
         self.event_key = event_key
         self.expression = expression
 
-    def to_pb(self) -> UserEventMatchCondition:
+    def to_proto(self) -> UserEventMatchCondition:
         return UserEventMatchCondition(
-            base=self.base.to_pb(),
+            base=self.base.to_proto(),
             user_event_key=self.event_key,
         )
 
@@ -103,9 +103,9 @@ class ParentCondition(Condition):
 
         self.parent = parent
 
-    def to_pb(self) -> ParentOverrideMatchCondition:
+    def to_proto(self) -> ParentOverrideMatchCondition:
         return ParentOverrideMatchCondition(
-            base=self.base.to_pb(),
+            base=self.base.to_proto(),
             parent_readable_id=self.parent.name,
         )
 

hatchet_sdk/worker/runner/run_loop_manager.py

@@ -55,17 +55,17 @@ class WorkerActionRunLoopManager:
         self.client = Client(config=self.config, debug=self.debug)
         self.start()
 
-    def start(self, retry_count: int = 1) -> None:
-        k = self.loop.create_task(self.aio_start(retry_count))  # noqa: F841
+    def start(self) -> None:
+        k = self.loop.create_task(self.aio_start())  # noqa: F841
 
     async def aio_start(self, retry_count: int = 1) -> None:
         await capture_logs(
             self.client.log_interceptor,
             self.client.event,
             self._async_start,
-        )(retry_count=retry_count)
+        )()
 
-    async def _async_start(self, retry_count: int = 1) -> None:
+    async def _async_start(self) -> None:
         logger.info("starting runner...")
         self.loop = asyncio.get_running_loop()
         # needed for graceful termination

hatchet_sdk/worker/runner/runner.py

@@ -16,9 +16,10 @@ from hatchet_sdk.client import Client
 from hatchet_sdk.clients.admin import AdminClient
 from hatchet_sdk.clients.dispatcher.action_listener import Action, ActionType
 from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
-from hatchet_sdk.clients.durable_event_listener import DurableEventListener
-from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
-from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
+from hatchet_sdk.clients.events import EventClient
+from hatchet_sdk.clients.listeners.durable_event_listener import DurableEventListener
+from hatchet_sdk.clients.listeners.run_event_listener import RunEventListenerClient
+from hatchet_sdk.clients.listeners.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.context.worker_context import WorkerContext
@@ -31,6 +32,7 @@ from hatchet_sdk.contracts.dispatcher_pb2 import (
     STEP_EVENT_TYPE_STARTED,
 )
 from hatchet_sdk.exceptions import NonRetryableException
+from hatchet_sdk.features.runs import RunsClient
 from hatchet_sdk.logger import logger
 from hatchet_sdk.runnables.contextvars import (
     ctx_step_run_id,
@@ -66,7 +68,7 @@ class Runner:
     ):
         # We store the config so we can dynamically create clients for the dispatcher client.
         self.config = config
-        self.client = Client(config)
+
         self.slots = slots
         self.tasks: dict[str, asyncio.Task[Any]] = {}  # Store run ids and futures
         self.contexts: dict[str, Context] = {}  # Store run ids and contexts
@@ -82,12 +84,21 @@ class Runner:
         self.killing = False
         self.handle_kill = handle_kill
 
-        # We need to initialize a new admin and dispatcher client *after* we've started the event loop,
-        # otherwise the grpc.aio methods will use a different event loop and we'll get a bunch of errors.
         self.dispatcher_client = DispatcherClient(self.config)
-        self.admin_client = AdminClient(self.config)
         self.workflow_run_event_listener = RunEventListenerClient(self.config)
-        self.client.workflow_listener = PooledWorkflowRunListener(self.config)
+        self.workflow_listener = PooledWorkflowRunListener(self.config)
+        self.runs_client = RunsClient(
+            config=self.config,
+            workflow_run_event_listener=self.workflow_run_event_listener,
+            workflow_run_listener=self.workflow_listener,
+        )
+        self.admin_client = AdminClient(
+            self.config,
+            self.workflow_listener,
+            self.workflow_run_event_listener,
+            self.runs_client,
+        )
+        self.event_client = EventClient(self.config)
         self.durable_event_listener = DurableEventListener(self.config)
 
         self.worker_context = WorkerContext(
@@ -291,11 +302,11 @@ class Runner:
             action=action,
             dispatcher_client=self.dispatcher_client,
             admin_client=self.admin_client,
-            event_client=self.client.event,
+            event_client=self.event_client,
             durable_event_listener=self.durable_event_listener,
             worker=self.worker_context,
             validator_registry=self.validator_registry,
-            runs_client=self.client.runs,
+            runs_client=self.runs_client,
         )
 
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
@@ -430,7 +441,7 @@ class Runner:
             # check if thread is still running, if so, print a warning
             if run_id in self.threads:
                 thread = self.threads.get(run_id)
-                if thread and self.client.config.enable_force_kill_sync_threads:
+                if thread and self.config.enable_force_kill_sync_threads:
                     self.force_kill_thread(thread)
                     await asyncio.sleep(1)