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

hatchet_sdk/features/cron.py

@@ -1,3 +1,5 @@
+import asyncio
+
 from pydantic import BaseModel, Field, field_validator
 
 from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
@@ -18,7 +20,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
 
 
@@ -77,7 +78,7 @@ class CronClient(BaseRestClient):
     def _wa(self, client: ApiClient) -> WorkflowApi:
         return WorkflowApi(client)
 
-    async def aio_create(
+    def create(
         self,
         workflow_name: str,
         cron_name: str,
@@ -102,8 +103,8 @@ class CronClient(BaseRestClient):
             expression=expression, input=input, additional_metadata=additional_metadata
         )
 
-        async with self.client() as client:
-            return await self._wra(client).cron_workflow_trigger_create(
+        with self.client() as client:
+            return self._wra(client).cron_workflow_trigger_create(
                 tenant=self.client_config.tenant_id,
                 workflow=workflow_name,
                 create_cron_workflow_trigger_request=CreateCronWorkflowTriggerRequest(
@@ -114,7 +115,7 @@ class CronClient(BaseRestClient):
                 ),
             )
 
-    def create(
+    async def aio_create(
         self,
         workflow_name: str,
         cron_name: str,
@@ -122,8 +123,8 @@ class CronClient(BaseRestClient):
         input: JSONSerializableMapping,
         additional_metadata: JSONSerializableMapping,
     ) -> CronWorkflows:
-        return run_async_from_sync(
-            self.aio_create,
+        return await asyncio.to_thread(
+            self.create,
             workflow_name,
             cron_name,
             expression,
@@ -131,20 +132,20 @@ class CronClient(BaseRestClient):
             additional_metadata,
         )
 
-    async def aio_delete(self, cron_id: str) -> None:
+    def delete(self, cron_id: str) -> None:
         """
         Asynchronously deletes a workflow cron trigger.
 
         Args:
             cron_id (str): The cron trigger ID or CronWorkflows instance to delete.
         """
-        async with self.client() as client:
-            await self._wa(client).workflow_cron_delete(
+        with self.client() as client:
+            self._wa(client).workflow_cron_delete(
                 tenant=self.client_config.tenant_id, cron_workflow=str(cron_id)
             )
 
-    def delete(self, cron_id: str) -> None:
-        return run_async_from_sync(self.aio_delete, cron_id)
+    async def aio_delete(self, cron_id: str) -> None:
+        return await asyncio.to_thread(self.delete, cron_id)
 
     async def aio_list(
         self,
@@ -156,7 +157,7 @@ class CronClient(BaseRestClient):
         order_by_direction: WorkflowRunOrderByDirection | None = None,
     ) -> CronWorkflowsList:
         """
-        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
+        Synchronously retrieves a list of all workflow cron triggers matching the criteria.
 
         Args:
             offset (int | None): The offset to start the list from.
@@ -169,18 +170,15 @@ class CronClient(BaseRestClient):
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        async with self.client() as client:
-            return await self._wa(client).cron_workflow_list(
-                tenant=self.client_config.tenant_id,
-                offset=offset,
-                limit=limit,
-                workflow_id=workflow_id,
-                additional_metadata=maybe_additional_metadata_to_kv(
-                    additional_metadata
-                ),
-                order_by_field=order_by_field,
-                order_by_direction=order_by_direction,
-            )
+        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,
+        )
 
     def list(
         self,
@@ -192,7 +190,7 @@ class CronClient(BaseRestClient):
         order_by_direction: WorkflowRunOrderByDirection | None = None,
     ) -> CronWorkflowsList:
         """
-        Synchronously retrieves a list of all workflow cron triggers matching the criteria.
+        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
 
         Args:
             offset (int | None): The offset to start the list from.
@@ -205,17 +203,20 @@ class CronClient(BaseRestClient):
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        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,
-        )
+        with self.client() as client:
+            return self._wa(client).cron_workflow_list(
+                tenant=self.client_config.tenant_id,
+                offset=offset,
+                limit=limit,
+                workflow_id=workflow_id,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                order_by_field=order_by_field,
+                order_by_direction=order_by_direction,
+            )
 
-    async def aio_get(self, cron_id: str) -> CronWorkflows:
+    def get(self, cron_id: str) -> CronWorkflows:
         """
         Asynchronously retrieves a specific workflow cron trigger by ID.
 
@@ -225,12 +226,12 @@ class CronClient(BaseRestClient):
         Returns:
             CronWorkflows: The requested cron workflow instance.
         """
-        async with self.client() as client:
-            return await self._wa(client).workflow_cron_get(
+        with self.client() as client:
+            return self._wa(client).workflow_cron_get(
                 tenant=self.client_config.tenant_id, cron_workflow=str(cron_id)
             )
 
-    def get(self, cron_id: str) -> CronWorkflows:
+    async def aio_get(self, cron_id: str) -> CronWorkflows:
         """
         Synchronously retrieves a specific workflow cron trigger by ID.
 
@@ -240,4 +241,4 @@ class CronClient(BaseRestClient):
         Returns:
             CronWorkflows: The requested cron workflow instance.
         """
-        return run_async_from_sync(self.aio_get, cron_id)
+        return await asyncio.to_thread(self.get, cron_id)

hatchet_sdk/features/logs.py

@@ -1,17 +1,18 @@
+import asyncio
+
 from hatchet_sdk.clients.rest.api.log_api import LogApi
 from hatchet_sdk.clients.rest.api_client import ApiClient
 from hatchet_sdk.clients.rest.models.v1_log_line_list import V1LogLineList
 from hatchet_sdk.clients.v1.api_client import BaseRestClient
-from hatchet_sdk.utils.aio import run_async_from_sync
 
 
 class LogsClient(BaseRestClient):
     def _la(self, client: ApiClient) -> LogApi:
         return LogApi(client)
 
-    async def aio_list(self, task_run_id: str) -> V1LogLineList:
-        async with self.client() as client:
-            return await self._la(client).v1_log_line_list(task=task_run_id)
-
     def list(self, task_run_id: str) -> V1LogLineList:
-        return run_async_from_sync(self.aio_list, task_run_id)
+        with self.client() as client:
+            return self._la(client).v1_log_line_list(task=task_run_id)
+
+    async def aio_list(self, task_run_id: str) -> V1LogLineList:
+        return await asyncio.to_thread(self.list, task_run_id)

hatchet_sdk/features/metrics.py

@@ -1,3 +1,5 @@
+import asyncio
+
 from hatchet_sdk.clients.rest.api.tenant_api import TenantApi
 from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
 from hatchet_sdk.clients.rest.api_client import ApiClient
@@ -11,7 +13,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
 
 
@@ -22,34 +23,34 @@ class MetricsClient(BaseRestClient):
     def _ta(self, client: ApiClient) -> TenantApi:
         return TenantApi(client)
 
-    async def aio_get_workflow_metrics(
+    def get_workflow_metrics(
         self,
         workflow_id: str,
         status: WorkflowRunStatus | None = None,
         group_key: str | None = None,
     ) -> WorkflowMetrics:
-        async with self.client() as client:
-            return await self._wa(client).workflow_get_metrics(
+        with self.client() as client:
+            return self._wa(client).workflow_get_metrics(
                 workflow=workflow_id, status=status, group_key=group_key
             )
 
-    def get_workflow_metrics(
+    async def aio_get_workflow_metrics(
         self,
         workflow_id: str,
         status: WorkflowRunStatus | None = None,
         group_key: str | None = None,
     ) -> WorkflowMetrics:
-        return run_async_from_sync(
-            self.aio_get_workflow_metrics, workflow_id, status, group_key
+        return await asyncio.to_thread(
+            self.get_workflow_metrics, workflow_id, status, group_key
         )
 
-    async def aio_get_queue_metrics(
+    def get_queue_metrics(
         self,
         workflow_ids: list[str] | None = None,
         additional_metadata: JSONSerializableMapping | None = None,
     ) -> TenantQueueMetrics:
-        async with self.client() as client:
-            return await self._wa(client).tenant_get_queue_metrics(
+        with self.client() as client:
+            return self._wa(client).tenant_get_queue_metrics(
                 tenant=self.client_config.tenant_id,
                 workflows=workflow_ids,
                 additional_metadata=maybe_additional_metadata_to_kv(
@@ -57,20 +58,20 @@ class MetricsClient(BaseRestClient):
                 ),
             )
 
-    def get_queue_metrics(
+    async def aio_get_queue_metrics(
         self,
         workflow_ids: list[str] | None = None,
         additional_metadata: JSONSerializableMapping | None = None,
     ) -> TenantQueueMetrics:
-        return run_async_from_sync(
-            self.aio_get_queue_metrics, workflow_ids, additional_metadata
+        return await asyncio.to_thread(
+            self.get_queue_metrics, workflow_ids, additional_metadata
         )
 
-    async def aio_get_task_metrics(self) -> TenantStepRunQueueMetrics:
-        async with self.client() as client:
-            return await self._ta(client).tenant_get_step_run_queue_metrics(
+    def get_task_metrics(self) -> TenantStepRunQueueMetrics:
+        with self.client() as client:
+            return self._ta(client).tenant_get_step_run_queue_metrics(
                 tenant=self.client_config.tenant_id
             )
 
-    def get_task_metrics(self) -> TenantStepRunQueueMetrics:
-        return run_async_from_sync(self.aio_get_task_metrics)
+    async def aio_get_task_metrics(self) -> TenantStepRunQueueMetrics:
+        return await asyncio.to_thread(self.get_task_metrics)

hatchet_sdk/features/runs.py

@@ -1,8 +1,11 @@
+import asyncio
 from datetime import datetime, timedelta
-from typing import Literal, overload
+from typing import TYPE_CHECKING, Literal, overload
 
 from pydantic import BaseModel, model_validator
 
+from hatchet_sdk.clients.listeners.run_event_listener import RunEventListenerClient
+from hatchet_sdk.clients.listeners.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.clients.rest.api.task_api import TaskApi
 from hatchet_sdk.clients.rest.api.workflow_runs_api import WorkflowRunsApi
 from hatchet_sdk.clients.rest.api_client import ApiClient
@@ -19,9 +22,11 @@ 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.config import ClientConfig
 from hatchet_sdk.utils.typing import JSONSerializableMapping
-from hatchet_sdk.workflow_run import WorkflowRunRef
+
+if TYPE_CHECKING:
+    from hatchet_sdk.workflow_run import WorkflowRunRef
 
 
 class RunFilter(BaseModel):
@@ -84,18 +89,29 @@ class BulkCancelReplayOpts(BaseModel):
 
 
 class RunsClient(BaseRestClient):
+    def __init__(
+        self,
+        config: ClientConfig,
+        workflow_run_listener: PooledWorkflowRunListener,
+        workflow_run_event_listener: RunEventListenerClient,
+    ) -> None:
+        super().__init__(config)
+
+        self.workflow_run_listener = workflow_run_listener
+        self.workflow_run_event_listener = workflow_run_event_listener
+
     def _wra(self, client: ApiClient) -> WorkflowRunsApi:
         return WorkflowRunsApi(client)
 
     def _ta(self, client: ApiClient) -> TaskApi:
         return TaskApi(client)
 
-    async def aio_get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
-        async with self.client() as client:
-            return await self._wra(client).v1_workflow_run_get(str(workflow_run_id))
-
     def get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
-        return run_async_from_sync(self.aio_get, workflow_run_id)
+        with self.client() as client:
+            return self._wra(client).v1_workflow_run_get(str(workflow_run_id))
+
+    async def aio_get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
+        return await asyncio.to_thread(self.get, workflow_run_id)
 
     async def aio_list(
         self,
@@ -110,22 +126,19 @@ class RunsClient(BaseRestClient):
         worker_id: str | None = None,
         parent_task_external_id: str | None = None,
     ) -> V1TaskSummaryList:
-        async with self.client() as client:
-            return await self._wra(client).v1_workflow_run_list(
-                tenant=self.client_config.tenant_id,
-                since=since,
-                only_tasks=only_tasks,
-                offset=offset,
-                limit=limit,
-                statuses=statuses,
-                until=until,
-                additional_metadata=maybe_additional_metadata_to_kv(
-                    additional_metadata
-                ),
-                workflow_ids=workflow_ids,
-                worker_id=worker_id,
-                parent_task_external_id=parent_task_external_id,
-            )
+        return await asyncio.to_thread(
+            self.list,
+            since=since,
+            only_tasks=only_tasks,
+            offset=offset,
+            limit=limit,
+            statuses=statuses,
+            until=until,
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+            worker_id=worker_id,
+            parent_task_external_id=parent_task_external_id,
+        )
 
     def list(
         self,
@@ -140,28 +153,31 @@ class RunsClient(BaseRestClient):
         worker_id: str | None = None,
         parent_task_external_id: str | None = None,
     ) -> V1TaskSummaryList:
-        return run_async_from_sync(
-            self.aio_list,
-            since=since,
-            only_tasks=only_tasks,
-            offset=offset,
-            limit=limit,
-            statuses=statuses,
-            until=until,
-            additional_metadata=additional_metadata,
-            workflow_ids=workflow_ids,
-            worker_id=worker_id,
-            parent_task_external_id=parent_task_external_id,
-        )
+        with self.client() as client:
+            return self._wra(client).v1_workflow_run_list(
+                tenant=self.client_config.tenant_id,
+                since=since,
+                only_tasks=only_tasks,
+                offset=offset,
+                limit=limit,
+                statuses=statuses,
+                until=until,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                workflow_ids=workflow_ids,
+                worker_id=worker_id,
+                parent_task_external_id=parent_task_external_id,
+            )
 
-    async def aio_create(
+    def create(
         self,
         workflow_name: str,
         input: JSONSerializableMapping,
         additional_metadata: JSONSerializableMapping = {},
     ) -> V1WorkflowRunDetails:
-        async with self.client() as client:
-            return await self._wra(client).v1_workflow_run_create(
+        with self.client() as client:
+            return self._wra(client).v1_workflow_run_create(
                 tenant=self.client_config.tenant_id,
                 v1_trigger_workflow_run_request=V1TriggerWorkflowRunRequest(
                     workflowName=workflow_name,
@@ -170,60 +186,64 @@ class RunsClient(BaseRestClient):
                 ),
             )
 
-    def create(
+    async def aio_create(
         self,
         workflow_name: str,
         input: JSONSerializableMapping,
         additional_metadata: JSONSerializableMapping = {},
     ) -> V1WorkflowRunDetails:
-        return run_async_from_sync(
-            self.aio_create, workflow_name, input, additional_metadata
+        return await asyncio.to_thread(
+            self.create, workflow_name, input, additional_metadata
         )
 
-    async def aio_replay(self, run_id: str) -> None:
-        await self.aio_bulk_replay(opts=BulkCancelReplayOpts(ids=[run_id]))
-
     def replay(self, run_id: str) -> None:
-        return run_async_from_sync(self.aio_replay, run_id)
+        self.bulk_replay(opts=BulkCancelReplayOpts(ids=[run_id]))
 
-    async def aio_bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
-        async with self.client() as client:
-            await self._ta(client).v1_task_replay(
+    async def aio_replay(self, run_id: str) -> None:
+        return await asyncio.to_thread(self.replay, run_id)
+
+    def bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
+        with self.client() as client:
+            self._ta(client).v1_task_replay(
                 tenant=self.client_config.tenant_id,
                 v1_replay_task_request=opts.to_request("replay"),
             )
 
-    def bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
-        return run_async_from_sync(self.aio_bulk_replay, opts)
-
-    async def aio_cancel(self, run_id: str) -> None:
-        await self.aio_bulk_cancel(opts=BulkCancelReplayOpts(ids=[run_id]))
+    async def aio_bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
+        return await asyncio.to_thread(self.bulk_replay, opts)
 
     def cancel(self, run_id: str) -> None:
-        return run_async_from_sync(self.aio_cancel, run_id)
+        self.bulk_cancel(opts=BulkCancelReplayOpts(ids=[run_id]))
 
-    async def aio_bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
-        async with self.client() as client:
-            await self._ta(client).v1_task_cancel(
+    async def aio_cancel(self, run_id: str) -> None:
+        return await asyncio.to_thread(self.cancel, run_id)
+
+    def bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
+        with self.client() as client:
+            self._ta(client).v1_task_cancel(
                 tenant=self.client_config.tenant_id,
                 v1_cancel_task_request=opts.to_request("cancel"),
             )
 
-    def bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
-        return run_async_from_sync(self.aio_bulk_cancel, opts)
-
-    async def aio_get_result(self, run_id: str) -> JSONSerializableMapping:
-        details = await self.aio_get(run_id)
-
-        return details.run.output
+    async def aio_bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
+        return await asyncio.to_thread(self.bulk_cancel, opts)
 
     def get_result(self, run_id: str) -> JSONSerializableMapping:
         details = self.get(run_id)
 
         return details.run.output
 
-    def get_run_ref(self, workflow_run_id: str) -> WorkflowRunRef:
+    def get_run_ref(self, workflow_run_id: str) -> "WorkflowRunRef":
+        from hatchet_sdk.workflow_run import WorkflowRunRef
+
         return WorkflowRunRef(
             workflow_run_id=workflow_run_id,
-            config=self.client_config,
+            workflow_run_event_listener=self.workflow_run_event_listener,
+            workflow_run_listener=self.workflow_run_listener,
+            runs_client=self,
         )
+
+    async def aio_get_result(self, run_id: str) -> JSONSerializableMapping:
+        details = await asyncio.to_thread(self.get, run_id)
+
+        return details.run.output