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

hatchet_sdk/features/scheduled.py

@@ -1,3 +1,4 @@
+import asyncio
 import datetime
 from typing import Optional
 
@@ -22,7 +23,6 @@ from hatchet_sdk.clients.v1.api_client import (
     BaseRestClient,
     maybe_additional_metadata_to_kv,
 )
-from hatchet_sdk.utils.aio import run_async_from_sync
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
 
@@ -33,7 +33,7 @@ class ScheduledClient(BaseRestClient):
     def _wa(self, client: ApiClient) -> WorkflowApi:
         return WorkflowApi(client)
 
-    async def aio_create(
+    def create(
         self,
         workflow_name: str,
         trigger_at: datetime.datetime,
@@ -52,8 +52,8 @@ class ScheduledClient(BaseRestClient):
         Returns:
             ScheduledWorkflows: The created scheduled workflow instance.
         """
-        async with self.client() as client:
-            return await self._wra(client).scheduled_workflow_run_create(
+        with self.client() as client:
+            return self._wra(client).scheduled_workflow_run_create(
                 tenant=self.client_config.tenant_id,
                 workflow=workflow_name,
                 schedule_workflow_run_request=ScheduleWorkflowRunRequest(
@@ -63,7 +63,7 @@ class ScheduledClient(BaseRestClient):
                 ),
             )
 
-    def create(
+    async def aio_create(
         self,
         workflow_name: str,
         trigger_at: datetime.datetime,
@@ -83,29 +83,29 @@ class ScheduledClient(BaseRestClient):
             ScheduledWorkflows: The created scheduled workflow instance.
         """
 
-        return run_async_from_sync(
-            self.aio_create,
+        return await asyncio.to_thread(
+            self.create,
             workflow_name,
             trigger_at,
             input,
             additional_metadata,
         )
 
-    async def aio_delete(self, scheduled_id: str) -> None:
+    def delete(self, scheduled_id: str) -> None:
         """
         Deletes a scheduled workflow run.
 
         Args:
             scheduled_id (str): The scheduled workflow trigger ID to delete.
         """
-        async with self.client() as client:
-            await self._wa(client).workflow_scheduled_delete(
+        with self.client() as client:
+            self._wa(client).workflow_scheduled_delete(
                 tenant=self.client_config.tenant_id,
                 scheduled_workflow_run=scheduled_id,
             )
 
-    def delete(self, scheduled_id: str) -> None:
-        run_async_from_sync(self.aio_delete, scheduled_id)
+    async def aio_delete(self, scheduled_id: str) -> None:
+        await asyncio.to_thread(self.delete, scheduled_id)
 
     async def aio_list(
         self,
@@ -134,20 +134,17 @@ class ScheduledClient(BaseRestClient):
         Returns:
             List[ScheduledWorkflows]: A list of scheduled workflows matching the criteria.
         """
-        async with self.client() as client:
-            return await self._wa(client).workflow_scheduled_list(
-                tenant=self.client_config.tenant_id,
-                offset=offset,
-                limit=limit,
-                order_by_field=order_by_field,
-                order_by_direction=order_by_direction,
-                workflow_id=workflow_id,
-                additional_metadata=maybe_additional_metadata_to_kv(
-                    additional_metadata
-                ),
-                parent_workflow_run_id=parent_workflow_run_id,
-                statuses=statuses,
-            )
+        return await asyncio.to_thread(
+            self.list,
+            offset=offset,
+            limit=limit,
+            workflow_id=workflow_id,
+            additional_metadata=additional_metadata,
+            order_by_field=order_by_field,
+            order_by_direction=order_by_direction,
+            parent_workflow_run_id=parent_workflow_run_id,
+            statuses=statuses,
+        )
 
     def list(
         self,
@@ -176,19 +173,22 @@ class ScheduledClient(BaseRestClient):
         Returns:
             List[ScheduledWorkflows]: A list of scheduled workflows matching the criteria.
         """
-        return run_async_from_sync(
-            self.aio_list,
-            offset=offset,
-            limit=limit,
-            workflow_id=workflow_id,
-            additional_metadata=additional_metadata,
-            order_by_field=order_by_field,
-            order_by_direction=order_by_direction,
-            parent_workflow_run_id=parent_workflow_run_id,
-            statuses=statuses,
-        )
+        with self.client() as client:
+            return self._wa(client).workflow_scheduled_list(
+                tenant=self.client_config.tenant_id,
+                offset=offset,
+                limit=limit,
+                order_by_field=order_by_field,
+                order_by_direction=order_by_direction,
+                workflow_id=workflow_id,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                parent_workflow_run_id=parent_workflow_run_id,
+                statuses=statuses,
+            )
 
-    async def aio_get(self, scheduled_id: str) -> ScheduledWorkflows:
+    def get(self, scheduled_id: str) -> ScheduledWorkflows:
         """
         Retrieves a specific scheduled workflow by scheduled run trigger ID.
 
@@ -199,13 +199,13 @@ class ScheduledClient(BaseRestClient):
             ScheduledWorkflows: The requested scheduled workflow instance.
         """
 
-        async with self.client() as client:
-            return await self._wa(client).workflow_scheduled_get(
+        with self.client() as client:
+            return self._wa(client).workflow_scheduled_get(
                 tenant=self.client_config.tenant_id,
                 scheduled_workflow_run=scheduled_id,
             )
 
-    def get(self, scheduled_id: str) -> ScheduledWorkflows:
+    async def aio_get(self, scheduled_id: str) -> ScheduledWorkflows:
         """
         Retrieves a specific scheduled workflow by scheduled run trigger ID.
 
@@ -215,4 +215,4 @@ class ScheduledClient(BaseRestClient):
         Returns:
             ScheduledWorkflows: The requested scheduled workflow instance.
         """
-        return run_async_from_sync(self.aio_get, scheduled_id)
+        return await asyncio.to_thread(self.get, scheduled_id)

hatchet_sdk/features/workers.py

@@ -1,42 +1,43 @@
+import asyncio
+
 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
-from hatchet_sdk.utils.aio import run_async_from_sync
 
 
 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 run_async_from_sync(self.aio_get, worker_id)
+        with self.client() as client:
+            return self._wa(client).worker_get(worker_id)
 
-    async def aio_list(
+    async def aio_get(self, worker_id: str) -> Worker:
+        return await asyncio.to_thread(self.get, worker_id)
+
+    def list(
         self,
     ) -> WorkerList:
-        async with self.client() as client:
-            return await self._wa(client).worker_list(
+        with self.client() as client:
+            return self._wa(client).worker_list(
                 tenant=self.client_config.tenant_id,
             )
 
-    def list(
+    async def aio_list(
         self,
     ) -> WorkerList:
-        return run_async_from_sync(self.aio_list)
+        return await asyncio.to_thread(self.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(
+    def update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
+        with self.client() as client:
+            return self._wa(client).worker_update(
                 worker=worker_id,
                 update_worker_request=opts,
             )
 
-    def update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
-        return run_async_from_sync(self.aio_update, worker_id, opts)
+    async def aio_update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
+        return await asyncio.to_thread(self.update, worker_id, opts)

hatchet_sdk/features/workflows.py

@@ -1,3 +1,5 @@
+import asyncio
+
 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
@@ -5,7 +7,6 @@ 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
-from hatchet_sdk.utils.aio import run_async_from_sync
 
 
 class WorkflowsClient(BaseRestClient):
@@ -16,41 +17,41 @@ class WorkflowsClient(BaseRestClient):
         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)
+        return await asyncio.to_thread(self.get, workflow_id)
 
     def get(self, workflow_id: str) -> Workflow:
-        return run_async_from_sync(self.aio_get, workflow_id)
+        with self.client() as client:
+            return self._wa(client).workflow_get(workflow_id)
 
-    async def aio_list(
+    def 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(
+        with self.client() as client:
+            return self._wa(client).workflow_list(
                 tenant=self.client_config.tenant_id,
                 limit=limit,
                 offset=offset,
                 name=workflow_name,
             )
 
-    def list(
+    async def aio_list(
         self,
         workflow_name: str | None = None,
         limit: int | None = None,
         offset: int | None = None,
     ) -> WorkflowList:
-        return run_async_from_sync(self.aio_list, workflow_name, limit, offset)
+        return await asyncio.to_thread(self.list, workflow_name, limit, offset)
 
-    async def aio_get_version(
+    def 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)
+        with self.client() as client:
+            return self._wa(client).workflow_version_get(workflow_id, version)
 
-    def get_version(
+    async def aio_get_version(
         self, workflow_id: str, version: str | None = None
     ) -> WorkflowVersion:
-        return run_async_from_sync(self.aio_get_version, workflow_id, version)
+        return await asyncio.to_thread(self.get_version, workflow_id, version)

hatchet_sdk/hatchet.py

@@ -6,7 +6,7 @@ from hatchet_sdk import Context, DurableContext
 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.run_event_listener import RunEventListenerClient
+from hatchet_sdk.clients.listeners.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

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)