hatchet-sdk 1.0.0a1__py3-none-any.whl → 1.0.2__py3-none-any.whl

hatchet_sdk/features/workers.py

@@ -0,0 +1,41 @@
+from hatchet_sdk.clients.rest.api.worker_api import WorkerApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.update_worker_request import UpdateWorkerRequest
+from hatchet_sdk.clients.rest.models.worker import Worker
+from hatchet_sdk.clients.rest.models.worker_list import WorkerList
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
+
+
+class WorkersClient(BaseRestClient):
+    def _wa(self, client: ApiClient) -> WorkerApi:
+        return WorkerApi(client)
+
+    async def aio_get(self, worker_id: str) -> Worker:
+        async with self.client() as client:
+            return await self._wa(client).worker_get(worker_id)
+
+    def get(self, worker_id: str) -> Worker:
+        return self._run_async_from_sync(self.aio_get, worker_id)
+
+    async def aio_list(
+        self,
+    ) -> WorkerList:
+        async with self.client() as client:
+            return await self._wa(client).worker_list(
+                tenant=self.client_config.tenant_id,
+            )
+
+    def list(
+        self,
+    ) -> WorkerList:
+        return self._run_async_from_sync(self.aio_list)
+
+    async def aio_update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
+        async with self.client() as client:
+            return await self._wa(client).worker_update(
+                worker=worker_id,
+                update_worker_request=opts,
+            )
+
+    def update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
+        return self._run_async_from_sync(self.aio_update, worker_id, opts)

hatchet_sdk/features/workflows.py

@@ -0,0 +1,55 @@
+from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
+from hatchet_sdk.clients.rest.api.workflow_run_api import WorkflowRunApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.workflow import Workflow
+from hatchet_sdk.clients.rest.models.workflow_list import WorkflowList
+from hatchet_sdk.clients.rest.models.workflow_version import WorkflowVersion
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
+
+
+class WorkflowsClient(BaseRestClient):
+    def _wra(self, client: ApiClient) -> WorkflowRunApi:
+        return WorkflowRunApi(client)
+
+    def _wa(self, client: ApiClient) -> WorkflowApi:
+        return WorkflowApi(client)
+
+    async def aio_get(self, workflow_id: str) -> Workflow:
+        async with self.client() as client:
+            return await self._wa(client).workflow_get(workflow_id)
+
+    def get(self, workflow_id: str) -> Workflow:
+        return self._run_async_from_sync(self.aio_get, workflow_id)
+
+    async def aio_list(
+        self,
+        workflow_name: str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> WorkflowList:
+        async with self.client() as client:
+            return await self._wa(client).workflow_list(
+                tenant=self.client_config.tenant_id,
+                limit=limit,
+                offset=offset,
+                name=workflow_name,
+            )
+
+    def list(
+        self,
+        workflow_name: str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> WorkflowList:
+        return self._run_async_from_sync(self.aio_list, workflow_name, limit, offset)
+
+    async def aio_get_version(
+        self, workflow_id: str, version: str | None = None
+    ) -> WorkflowVersion:
+        async with self.client() as client:
+            return await self._wa(client).workflow_version_get(workflow_id, version)
+
+    def get_version(
+        self, workflow_id: str, version: str | None = None
+    ) -> WorkflowVersion:
+        return self._run_async_from_sync(self.aio_get_version, workflow_id, version)

hatchet_sdk/hatchet.py

@@ -4,14 +4,18 @@ from typing import Any, Callable, Type, cast, overload
 
 from hatchet_sdk import Context, DurableContext
 from hatchet_sdk.client import Client
-from hatchet_sdk.clients.admin import AdminClient
 from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
 from hatchet_sdk.clients.events import EventClient
-from hatchet_sdk.clients.rest_client import RestApi
 from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.features.cron import CronClient
+from hatchet_sdk.features.logs import LogsClient
+from hatchet_sdk.features.metrics import MetricsClient
+from hatchet_sdk.features.rate_limits import RateLimitsClient
+from hatchet_sdk.features.runs import RunsClient
 from hatchet_sdk.features.scheduled import ScheduledClient
+from hatchet_sdk.features.workers import WorkersClient
+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
@@ -48,10 +52,6 @@ class Hatchet:
         rest (RestApi): Interface for REST API operations.
     """
 
-    _client: Client
-    cron: CronClient
-    scheduled: ScheduledClient
-
     def __init__(
         self,
         debug: bool = False,
@@ -75,12 +75,38 @@ class Hatchet:
             logger.setLevel(logging.DEBUG)
 
         self._client = client if client else Client(config=config, debug=debug)
-        self.cron = CronClient(self._client)
-        self.scheduled = ScheduledClient(self._client)
 
     @property
-    def admin(self) -> AdminClient:
-        return self._client.admin
+    def cron(self) -> CronClient:
+        return self._client.cron
+
+    @property
+    def logs(self) -> LogsClient:
+        return self._client.logs
+
+    @property
+    def metrics(self) -> MetricsClient:
+        return self._client.metrics
+
+    @property
+    def rate_limits(self) -> RateLimitsClient:
+        return self._client.rate_limits
+
+    @property
+    def runs(self) -> RunsClient:
+        return self._client.runs
+
+    @property
+    def scheduled(self) -> ScheduledClient:
+        return self._client.scheduled
+
+    @property
+    def workers(self) -> WorkersClient:
+        return self._client.workers
+
+    @property
+    def workflows(self) -> WorkflowsClient:
+        return self._client.workflows
 
     @property
     def dispatcher(self) -> DispatcherClient:
@@ -90,10 +116,6 @@ class Hatchet:
     def event(self) -> EventClient:
         return self._client.event
 
-    @property
-    def rest(self) -> RestApi:
-        return self._client.rest
-
     @property
     def listener(self) -> RunEventListenerClient:
         return self._client.listener

hatchet_sdk/runnables/standalone.py

@@ -2,8 +2,6 @@ import asyncio
 from datetime import datetime
 from typing import Any, Generic, cast, get_type_hints
 
-from google.protobuf import timestamp_pb2
-
 from hatchet_sdk.clients.admin import (
     ScheduleTriggerWorkflowOptions,
     TriggerWorkflowOptions,
@@ -12,7 +10,7 @@ from hatchet_sdk.clients.admin import (
 from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
 from hatchet_sdk.contracts.workflows_pb2 import WorkflowVersion
 from hatchet_sdk.runnables.task import Task
-from hatchet_sdk.runnables.types import R, TWorkflowInput
+from hatchet_sdk.runnables.types import EmptyModel, R, TWorkflowInput
 from hatchet_sdk.runnables.workflow import BaseWorkflow, Workflow
 from hatchet_sdk.utils.aio_utils import get_active_event_loop
 from hatchet_sdk.utils.typing import JSONSerializableMapping, is_basemodel_subclass
@@ -81,14 +79,14 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
     def run(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> R:
         return self._extract_result(self._workflow.run(input, options))
 
     async def aio_run(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> R:
         result = await self._workflow.aio_run(input, options)
@@ -96,7 +94,7 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
     def run_no_wait(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> TaskRunRef[TWorkflowInput, R]:
         ref = self._workflow.run_no_wait(input, options)
@@ -105,7 +103,7 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
     async def aio_run_no_wait(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> TaskRunRef[TWorkflowInput, R]:
         ref = await self._workflow.aio_run_no_wait(input, options)
@@ -140,24 +138,24 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
     def schedule(
         self,
-        schedules: list[datetime],
+        run_at: datetime,
         input: TWorkflowInput | None = None,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
         return self._workflow.schedule(
-            schedules=schedules,
+            run_at=run_at,
             input=input,
             options=options,
         )
 
     async def aio_schedule(
         self,
-        schedules: list[datetime | timestamp_pb2.Timestamp],
+        run_at: datetime,
         input: TWorkflowInput,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
         return await self._workflow.aio_schedule(
-            schedules=schedules,
+            run_at=run_at,
             input=input,
             options=options,
         )

hatchet_sdk/runnables/types.py

@@ -21,7 +21,7 @@ DEFAULT_PRIORITY = 1
 
 
 class EmptyModel(BaseModel):
-    model_config = ConfigDict(extra="allow")
+    model_config = ConfigDict(extra="allow", frozen=True)
 
 
 class StickyStrategy(str, Enum):

hatchet_sdk/runnables/workflow.py

@@ -29,6 +29,7 @@ from hatchet_sdk.runnables.types import (
     DEFAULT_EXECUTION_TIMEOUT,
     DEFAULT_SCHEDULE_TIMEOUT,
     ConcurrencyExpression,
+    EmptyModel,
     R,
     StepType,
     TWorkflowInput,
@@ -271,7 +272,7 @@ class BaseWorkflow(Generic[TWorkflowInput]):
     def is_durable(self) -> bool:
         return any(task.is_durable for task in self.tasks)
 
-    def create_run_workflow_config(
+    def create_bulk_run_item(
         self,
         input: TWorkflowInput | None = None,
         key: str | None = None,
@@ -293,10 +294,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
 
     def run_no_wait(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
-        return self.client.admin.run_workflow(
+        return self.client._client.admin.run_workflow(
             workflow_name=self.config.name,
             input=input.model_dump() if input else {},
             options=options,
@@ -304,10 +305,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
 
     def run(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> dict[str, Any]:
-        ref = self.client.admin.run_workflow(
+        ref = self.client._client.admin.run_workflow(
             workflow_name=self.config.name,
             input=input.model_dump() if input else {},
             options=options,
@@ -317,10 +318,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
 
     async def aio_run_no_wait(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
-        return await self.client.admin.aio_run_workflow(
+        return await self.client._client.admin.aio_run_workflow(
             workflow_name=self.config.name,
             input=input.model_dump() if input else {},
             options=options,
@@ -328,10 +329,10 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
 
     async def aio_run(
         self,
-        input: TWorkflowInput | None = None,
+        input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> dict[str, Any]:
-        ref = await self.client.admin.aio_run_workflow(
+        ref = await self.client._client.admin.aio_run_workflow(
             workflow_name=self.config.name,
             input=input.model_dump() if input else {},
             options=options,
@@ -343,7 +344,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[dict[str, Any]]:
-        refs = self.client.admin.run_workflows(
+        refs = self.client._client.admin.run_workflows(
             workflows=workflows,
         )
 
@@ -353,7 +354,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[dict[str, Any]]:
-        refs = await self.client.admin.aio_run_workflows(
+        refs = await self.client._client.admin.aio_run_workflows(
             workflows=workflows,
         )
 
@@ -363,7 +364,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[WorkflowRunRef]:
-        return self.client.admin.run_workflows(
+        return self.client._client.admin.run_workflows(
             workflows=workflows,
         )
 
@@ -371,32 +372,32 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[WorkflowRunRef]:
-        return await self.client.admin.aio_run_workflows(
+        return await self.client._client.admin.aio_run_workflows(
             workflows=workflows,
         )
 
     def schedule(
         self,
-        schedules: list[datetime],
+        run_at: datetime,
         input: TWorkflowInput | None = None,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
-        return self.client.admin.schedule_workflow(
+        return self.client._client.admin.schedule_workflow(
             name=self.config.name,
-            schedules=cast(list[datetime | timestamp_pb2.Timestamp], schedules),
+            schedules=cast(list[datetime | timestamp_pb2.Timestamp], [run_at]),
             input=input.model_dump() if input else {},
             options=options,
         )
 
     async def aio_schedule(
         self,
-        schedules: list[datetime | timestamp_pb2.Timestamp],
+        run_at: datetime,
         input: TWorkflowInput,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
-        return await self.client.admin.aio_schedule_workflow(
+        return await self.client._client.admin.aio_schedule_workflow(
             name=self.config.name,
-            schedules=schedules,
+            schedules=cast(list[datetime | timestamp_pb2.Timestamp], [run_at]),
             input=input.model_dump(),
             options=options,
         )
@@ -661,6 +662,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 concurrency=concurrency,
             )
 
+            if self._on_failure_task:
+                raise ValueError("Only one on-failure task is allowed")
+
             self._on_failure_task = task
 
             return task
@@ -722,6 +726,9 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 parents=[],
             )
 
+            if self._on_failure_task:
+                raise ValueError("Only one on-failure task is allowed")
+
             self._on_success_task = task
 
             return task

hatchet_sdk/worker/action_listener_process.py

@@ -98,9 +98,9 @@ class WorkerActionListenerProcess:
         if self.listener is None:
             raise ValueError("listener not started")
 
-        await self.client.rest.worker_api.worker_update(
-            worker=self.listener.worker_id,
-            update_worker_request=UpdateWorkerRequest(isPaused=True),
+        await self.client.workers.aio_update(
+            worker_id=self.listener.worker_id,
+            opts=UpdateWorkerRequest(isPaused=True),
         )
 
     async def start(self, retry_attempt: int = 0) -> None:

hatchet_sdk/worker/runner/run_loop_manager.py

@@ -83,7 +83,6 @@ class WorkerActionRunLoopManager:
 
     async def _start_action_loop(self) -> None:
         self.runner = Runner(
-            self.name,
             self.event_queue,
             self.config,
             self.slots,

hatchet_sdk/worker/runner/runner.py

@@ -55,7 +55,6 @@ class WorkerStatus(Enum):
 class Runner:
     def __init__(
         self,
-        name: str,
         event_queue: "Queue[ActionEvent]",
         config: ClientConfig,
         slots: int | None = None,
@@ -67,7 +66,6 @@ class Runner:
         # We store the config so we can dynamically create clients for the dispatcher client.
         self.config = config
         self.client = Client(config)
-        self.name = self.client.config.namespace + name
         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
@@ -125,6 +123,7 @@ class Runner:
 
             errored = False
             cancelled = task.cancelled()
+            output = None
 
             # Get the output from the future
             try:
@@ -169,6 +168,7 @@ class Runner:
 
             errored = False
             cancelled = task.cancelled()
+            output = None
 
             # Get the output from the future
             try:
@@ -206,12 +206,9 @@ class Runner:
     def thread_action_func(
         self, ctx: Context, task: Task[TWorkflowInput, R], action: Action
     ) -> R:
-        if action.step_run_id is not None and action.step_run_id != "":
+        if action.step_run_id:
             self.threads[action.step_run_id] = current_thread()
-        elif (
-            action.get_group_key_run_id is not None
-            and action.get_group_key_run_id != ""
-        ):
+        elif action.get_group_key_run_id:
             self.threads[action.get_group_key_run_id] = current_thread()
 
         return task.call(ctx)
@@ -286,12 +283,8 @@ class Runner:
             self.dispatcher_client,
             self.admin_client,
             self.client.event,
-            self.client.rest,
-            self.client.workflow_listener,
             self.durable_event_listener,
-            self.workflow_run_event_listener,
             self.worker_context,
-            self.client.config.namespace,
             validator_registry=self.validator_registry,
         )
 

hatchet_sdk/worker/runner/utils/capture_logs.py

@@ -63,9 +63,6 @@ def capture_logs(
 ) -> Callable[P, Awaitable[T]]:
     @functools.wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-        if not logger:
-            raise Exception("No logger configured on client")
-
         log_stream = StringIO()
         custom_handler = CustomLogHandler(event_client, log_stream)
         custom_handler.setLevel(logging.INFO)

hatchet_sdk/worker/worker.py

@@ -103,7 +103,7 @@ class Worker:
         self.durable_action_queue: "Queue[Action | STOP_LOOP_TYPE]" = self.ctx.Queue()
         self.durable_event_queue: "Queue[ActionEvent]" = self.ctx.Queue()
 
-        self.loop: asyncio.AbstractEventLoop
+        self.loop: asyncio.AbstractEventLoop | None
 
         self.client = Client(config=self.config, debug=self.debug)
 
@@ -226,6 +226,9 @@ class Worker:
     def start(self, options: WorkerStartOptions = WorkerStartOptions()) -> None:
         self.owned_loop = self._setup_loop(options.loop)
 
+        if not self.loop:
+            raise RuntimeError("event loop not set, cannot start worker")
+
         asyncio.run_coroutine_threadsafe(self._aio_start(), self.loop)
 
         # start the loop and wait until its closed
@@ -265,27 +268,31 @@ class Worker:
             )
             self.durable_action_runner = self._run_action_runner(is_durable=True)
 
-        self.action_listener_health_check = self.loop.create_task(
-            self._check_listener_health()
-        )
+        if self.loop:
+            self.action_listener_health_check = self.loop.create_task(
+                self._check_listener_health()
+            )
 
-        await self.action_listener_health_check
+            await self.action_listener_health_check
 
     def _run_action_runner(self, is_durable: bool) -> WorkerActionRunLoopManager:
         # Retrieve the shared queue
-        return WorkerActionRunLoopManager(
-            self.name + ("_durable" if is_durable else ""),
-            self.durable_action_registry if is_durable else self.action_registry,
-            self.validator_registry,
-            1_000 if is_durable else self.slots,
-            self.config,
-            self.durable_action_queue if is_durable else self.action_queue,
-            self.durable_event_queue if is_durable else self.event_queue,
-            self.loop,
-            self.handle_kill,
-            self.client.debug,
-            self.labels,
-        )
+        if self.loop:
+            return WorkerActionRunLoopManager(
+                self.name + ("_durable" if is_durable else ""),
+                self.durable_action_registry if is_durable else self.action_registry,
+                self.validator_registry,
+                1_000 if is_durable else self.slots,
+                self.config,
+                self.durable_action_queue if is_durable else self.action_queue,
+                self.durable_event_queue if is_durable else self.event_queue,
+                self.loop,
+                self.handle_kill,
+                self.client.debug,
+                self.labels,
+            )
+
+        raise RuntimeError("event loop not set, cannot start action runner")
 
     def _start_action_listener(
         self, is_durable: bool
@@ -332,7 +339,7 @@ class Worker:
                 ):
                     logger.debug("child action listener process killed...")
                     self._status = WorkerStatus.UNHEALTHY
-                    if not self.killing:
+                    if self.loop:
                         self.loop.create_task(self.exit_gracefully())
                     break
                 else:
@@ -349,11 +356,13 @@ class Worker:
     def _handle_exit_signal(self, signum: int, frame: FrameType | None) -> None:
         sig_name = "SIGTERM" if signum == signal.SIGTERM else "SIGINT"
         logger.info(f"received signal {sig_name}...")
-        self.loop.create_task(self.exit_gracefully())
+        if self.loop:
+            self.loop.create_task(self.exit_gracefully())
 
     def _handle_force_quit_signal(self, signum: int, frame: FrameType | None) -> None:
         logger.info("received SIGQUIT...")
-        self.loop.create_task(self._exit_forcefully())
+        if self.loop:
+            self.loop.create_task(self._exit_forcefully())
 
     async def _close(self) -> None:
         logger.info(f"closing worker '{self.name}'...")

{hatchet_sdk-1.0.0a1.dist-info → hatchet_sdk-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.0.0a1
+Version: 1.0.2
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run
@@ -29,6 +29,7 @@ Requires-Dist: prometheus-client (>=0.21.1,<0.22.0)
 Requires-Dist: protobuf (>=5.29.1,<6.0.0)
 Requires-Dist: pydantic (>=2.6.3,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.7.1,<3.0.0)
+Requires-Dist: pytest-timeout (>=2.3.1,<3.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: tenacity (>=8.4.1)