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

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

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