hatchet-sdk 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

hatchet_sdk/clients/v1/api_client.py

@@ -1,6 +1,4 @@
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-from typing import AsyncContextManager, Callable, Coroutine, ParamSpec, TypeVar
+from typing import AsyncContextManager, ParamSpec, TypeVar
 
 from hatchet_sdk.clients.rest.api_client import ApiClient
 from hatchet_sdk.clients.rest.configuration import Configuration
@@ -44,38 +42,3 @@ class BaseRestClient:
 
     def client(self) -> AsyncContextManager[ApiClient]:
         return ApiClient(self.api_config)
-
-    def _run_async_function_do_not_use_directly(
-        self,
-        async_func: Callable[P, Coroutine[Y, S, R]],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> R:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            return loop.run_until_complete(async_func(*args, **kwargs))
-        finally:
-            loop.close()
-
-    def _run_async_from_sync(
-        self,
-        async_func: Callable[P, Coroutine[Y, S, R]],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> R:
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = None
-
-        if loop and loop.is_running():
-            return loop.run_until_complete(async_func(*args, **kwargs))
-        else:
-            with ThreadPoolExecutor() as executor:
-                future = executor.submit(
-                    lambda: self._run_async_function_do_not_use_directly(
-                        async_func, *args, **kwargs
-                    )
-                )
-                return future.result()

hatchet_sdk/clients/workflow_listener.py

@@ -54,14 +54,6 @@ class _Subscription:
 
 class PooledWorkflowRunListener:
     def __init__(self, config: ClientConfig):
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        conn = new_conn(config, True)
-        self.client = DispatcherStub(conn)  # type: ignore[no-untyped-call]
         self.token = config.token
         self.config = config
 
@@ -91,6 +83,10 @@ class PooledWorkflowRunListener:
 
         self.interrupter: asyncio.Task[None] | None = None
 
+        ## IMPORTANT: This needs to be created lazily so we don't require
+        ## an event loop to instantiate the client.
+        self.client: DispatcherStub | None = None
+
     async def _interrupter(self) -> None:
         """
         _interrupter runs in a separate thread and interrupts the listener according to a configurable duration.
@@ -239,7 +235,7 @@ class PooledWorkflowRunListener:
             if subscription_id:
                 self.cleanup_subscription(subscription_id)
 
-    async def result(self, workflow_run_id: str) -> dict[str, Any]:
+    async def aio_result(self, workflow_run_id: str) -> dict[str, Any]:
         from hatchet_sdk.clients.admin import DedupeViolationErr
 
         event = await self.subscribe(workflow_run_id)
@@ -261,6 +257,9 @@ class PooledWorkflowRunListener:
         self,
     ) -> grpc.aio.UnaryStreamCall[SubscribeToWorkflowRunsRequest, WorkflowRunEvent]:
         retries = 0
+        if self.client is None:
+            conn = new_conn(self.config, True)
+            self.client = DispatcherStub(conn)
 
         while retries < DEFAULT_WORKFLOW_LISTENER_RETRY_COUNT:
             try:
@@ -276,7 +275,7 @@ class PooledWorkflowRunListener:
                         SubscribeToWorkflowRunsRequest, WorkflowRunEvent
                     ],
                     self.client.SubscribeToWorkflowRuns(
-                        self._request(),
+                        self._request(),  # type: ignore[arg-type]
                         metadata=get_metadata(self.token),
                     ),
                 )

hatchet_sdk/context/context.py

@@ -113,6 +113,14 @@ class Context:
 
         return parent_step_data
 
+    def aio_task_output(self, task: "Task[TWorkflowInput, R]") -> "R":
+        if task.is_async_function:
+            return self.task_output(task)
+
+        raise ValueError(
+            f"Task '{task.name}' is not an async function. Use `task_output` instead."
+        )
+
     @property
     def was_triggered_by_event(self) -> bool:
         return self.data.triggered_by == "event"
@@ -157,6 +165,7 @@ class Context:
 
         def handle_result(future: Future[tuple[bool, Exception | None]]) -> None:
             success, exception = future.result()
+
             if not success and exception:
                 if raise_on_error:
                     raise exception

hatchet_sdk/contracts/dispatcher_pb2_grpc.py

@@ -33,7 +33,7 @@ if _version_not_supported:
 class DispatcherStub(object):
     """Missing associated documentation comment in .proto file."""
 
-    def __init__(self, channel):
+    def __init__(self, channel: grpc.Channel | grpc.aio.Channel) -> None:
         """Constructor.
 
         Args:

hatchet_sdk/contracts/events_pb2_grpc.py

@@ -33,7 +33,7 @@ if _version_not_supported:
 class EventsServiceStub(object):
     """Missing associated documentation comment in .proto file."""
 
-    def __init__(self, channel):
+    def __init__(self, channel: grpc.Channel | grpc.aio.Channel) -> None:
         """Constructor.
 
         Args:

hatchet_sdk/contracts/v1/dispatcher_pb2_grpc.py

@@ -33,7 +33,7 @@ if _version_not_supported:
 class V1DispatcherStub(object):
     """Missing associated documentation comment in .proto file."""
 
-    def __init__(self, channel):
+    def __init__(self, channel: grpc.Channel | grpc.aio.Channel) -> None:
         """Constructor.
 
         Args:

hatchet_sdk/contracts/v1/workflows_pb2_grpc.py

@@ -34,7 +34,7 @@ class AdminServiceStub(object):
     """AdminService represents a set of RPCs for admin management of tasks, workflows, etc.
     """
 
-    def __init__(self, channel):
+    def __init__(self, channel: grpc.Channel | grpc.aio.Channel) -> None:
         """Constructor.
 
         Args:

hatchet_sdk/contracts/workflows_pb2_grpc.py

@@ -34,7 +34,7 @@ class WorkflowServiceStub(object):
     """WorkflowService represents a set of RPCs for managing workflows.
     """
 
-    def __init__(self, channel):
+    def __init__(self, channel: grpc.Channel | grpc.aio.Channel) -> None:
         """Constructor.
 
         Args:

hatchet_sdk/features/cron.py

@@ -18,6 +18,7 @@ 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
 
 
@@ -121,7 +122,7 @@ class CronClient(BaseRestClient):
         input: JSONSerializableMapping,
         additional_metadata: JSONSerializableMapping,
     ) -> CronWorkflows:
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_create,
             workflow_name,
             cron_name,
@@ -143,7 +144,7 @@ class CronClient(BaseRestClient):
             )
 
     def delete(self, cron_id: str) -> None:
-        return self._run_async_from_sync(self.aio_delete, cron_id)
+        return run_async_from_sync(self.aio_delete, cron_id)
 
     async def aio_list(
         self,
@@ -204,7 +205,7 @@ class CronClient(BaseRestClient):
         Returns:
             CronWorkflowsList: A list of cron workflows.
         """
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_list,
             offset=offset,
             limit=limit,
@@ -239,4 +240,4 @@ class CronClient(BaseRestClient):
         Returns:
             CronWorkflows: The requested cron workflow instance.
         """
-        return self._run_async_from_sync(self.aio_get, cron_id)
+        return run_async_from_sync(self.aio_get, cron_id)

hatchet_sdk/features/logs.py

@@ -2,6 +2,7 @@ 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):
@@ -13,4 +14,4 @@ class LogsClient(BaseRestClient):
             return await self._la(client).v1_log_line_list(task=task_run_id)
 
     def list(self, task_run_id: str) -> V1LogLineList:
-        return self._run_async_from_sync(self.aio_list, task_run_id)
+        return run_async_from_sync(self.aio_list, task_run_id)

hatchet_sdk/features/metrics.py

@@ -11,6 +11,7 @@ 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
 
 
@@ -38,7 +39,7 @@ class MetricsClient(BaseRestClient):
         status: WorkflowRunStatus | None = None,
         group_key: str | None = None,
     ) -> WorkflowMetrics:
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_get_workflow_metrics, workflow_id, status, group_key
         )
 
@@ -61,7 +62,7 @@ class MetricsClient(BaseRestClient):
         workflow_ids: list[str] | None = None,
         additional_metadata: JSONSerializableMapping | None = None,
     ) -> TenantQueueMetrics:
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_get_queue_metrics, workflow_ids, additional_metadata
         )
 
@@ -72,4 +73,4 @@ class MetricsClient(BaseRestClient):
             )
 
     def get_task_metrics(self) -> TenantStepRunQueueMetrics:
-        return self._run_async_from_sync(self.aio_get_task_metrics)
+        return run_async_from_sync(self.aio_get_task_metrics)

hatchet_sdk/features/rate_limits.py

@@ -24,7 +24,7 @@ class RateLimitsClient(BaseRestClient):
         )
 
         conn = new_conn(self.client_config, False)
-        client = WorkflowServiceStub(conn)  # type: ignore[no-untyped-call]
+        client = WorkflowServiceStub(conn)
 
         client.PutRateLimit(
             v0_workflow_protos.PutRateLimitRequest(

hatchet_sdk/features/runs.py

@@ -19,6 +19,7 @@ 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
 
 
@@ -93,7 +94,7 @@ class RunsClient(BaseRestClient):
             return await self._wra(client).v1_workflow_run_get(str(workflow_run_id))
 
     def get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
-        return self._run_async_from_sync(self.aio_get, workflow_run_id)
+        return run_async_from_sync(self.aio_get, workflow_run_id)
 
     async def aio_list(
         self,
@@ -138,7 +139,7 @@ class RunsClient(BaseRestClient):
         worker_id: str | None = None,
         parent_task_external_id: str | None = None,
     ) -> V1TaskSummaryList:
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_list,
             since=since,
             only_tasks=only_tasks,
@@ -174,7 +175,7 @@ class RunsClient(BaseRestClient):
         input: JSONSerializableMapping,
         additional_metadata: JSONSerializableMapping = {},
     ) -> V1WorkflowRunDetails:
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_create, workflow_name, input, additional_metadata
         )
 
@@ -182,7 +183,7 @@ class RunsClient(BaseRestClient):
         await self.aio_bulk_replay(opts=BulkCancelReplayOpts(ids=[run_id]))
 
     def replay(self, run_id: str) -> None:
-        return self._run_async_from_sync(self.aio_replay, run_id)
+        return run_async_from_sync(self.aio_replay, run_id)
 
     async def aio_bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
         async with self.client() as client:
@@ -192,13 +193,13 @@ class RunsClient(BaseRestClient):
             )
 
     def bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
-        return self._run_async_from_sync(self.aio_bulk_replay, opts)
+        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]))
 
     def cancel(self, run_id: str) -> None:
-        return self._run_async_from_sync(self.aio_cancel, run_id)
+        return run_async_from_sync(self.aio_cancel, run_id)
 
     async def aio_bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
         async with self.client() as client:
@@ -208,7 +209,7 @@ class RunsClient(BaseRestClient):
             )
 
     def bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
-        return self._run_async_from_sync(self.aio_bulk_cancel, opts)
+        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)

hatchet_sdk/features/scheduled.py

@@ -22,6 +22,7 @@ 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
 
 
@@ -82,7 +83,7 @@ class ScheduledClient(BaseRestClient):
             ScheduledWorkflows: The created scheduled workflow instance.
         """
 
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_create,
             workflow_name,
             trigger_at,
@@ -104,7 +105,7 @@ class ScheduledClient(BaseRestClient):
             )
 
     def delete(self, scheduled_id: str) -> None:
-        self._run_async_from_sync(self.aio_delete, scheduled_id)
+        run_async_from_sync(self.aio_delete, scheduled_id)
 
     async def aio_list(
         self,
@@ -175,7 +176,7 @@ class ScheduledClient(BaseRestClient):
         Returns:
             List[ScheduledWorkflows]: A list of scheduled workflows matching the criteria.
         """
-        return self._run_async_from_sync(
+        return run_async_from_sync(
             self.aio_list,
             offset=offset,
             limit=limit,
@@ -214,4 +215,4 @@ class ScheduledClient(BaseRestClient):
         Returns:
             ScheduledWorkflows: The requested scheduled workflow instance.
         """
-        return self._run_async_from_sync(self.aio_get, scheduled_id)
+        return run_async_from_sync(self.aio_get, scheduled_id)

hatchet_sdk/features/workers.py

@@ -4,6 +4,7 @@ from hatchet_sdk.clients.rest.models.update_worker_request import UpdateWorkerRe
 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):
@@ -15,7 +16,7 @@ class WorkersClient(BaseRestClient):
             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)
+        return run_async_from_sync(self.aio_get, worker_id)
 
     async def aio_list(
         self,
@@ -28,7 +29,7 @@ class WorkersClient(BaseRestClient):
     def list(
         self,
     ) -> WorkerList:
-        return self._run_async_from_sync(self.aio_list)
+        return run_async_from_sync(self.aio_list)
 
     async def aio_update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
         async with self.client() as client:
@@ -38,4 +39,4 @@ class WorkersClient(BaseRestClient):
             )
 
     def update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
-        return self._run_async_from_sync(self.aio_update, worker_id, opts)
+        return run_async_from_sync(self.aio_update, worker_id, opts)

hatchet_sdk/features/workflows.py

@@ -5,6 +5,7 @@ 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):
@@ -19,7 +20,7 @@ class WorkflowsClient(BaseRestClient):
             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)
+        return run_async_from_sync(self.aio_get, workflow_id)
 
     async def aio_list(
         self,
@@ -41,7 +42,7 @@ class WorkflowsClient(BaseRestClient):
         limit: int | None = None,
         offset: int | None = None,
     ) -> WorkflowList:
-        return self._run_async_from_sync(self.aio_list, workflow_name, limit, offset)
+        return run_async_from_sync(self.aio_list, workflow_name, limit, offset)
 
     async def aio_get_version(
         self, workflow_id: str, version: str | None = None
@@ -52,4 +53,4 @@ class WorkflowsClient(BaseRestClient):
     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)
+        return run_async_from_sync(self.aio_get_version, workflow_id, version)

hatchet_sdk/metadata.py

@@ -1,2 +1,2 @@
-def get_metadata(token: str) -> list[tuple[str, str]]:
-    return [("authorization", "bearer " + token)]
+def get_metadata(token: str) -> tuple[tuple[str, str]]:
+    return (("authorization", "bearer " + token),)

hatchet_sdk/runnables/standalone.py

@@ -1,4 +1,3 @@
-import asyncio
 from datetime import datetime
 from typing import Any, Generic, cast, get_type_hints
 
@@ -12,7 +11,7 @@ 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_utils import get_active_event_loop
+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
 
@@ -27,25 +26,11 @@ class TaskRunRef(Generic[TWorkflowInput, R]):
         self._wrr = workflow_run_ref
 
     async def aio_result(self) -> R:
-        result = await self._wrr.workflow_listener.result(self._wrr.workflow_run_id)
+        result = await self._wrr.workflow_listener.aio_result(self._wrr.workflow_run_id)
         return self._s._extract_result(result)
 
     def result(self) -> R:
-        coro = self._wrr.workflow_listener.result(self._wrr.workflow_run_id)
-
-        loop = get_active_event_loop()
-
-        if loop is None:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                result = loop.run_until_complete(coro)
-            finally:
-                asyncio.set_event_loop(None)
-        else:
-            result = loop.run_until_complete(coro)
-
-        return self._s._extract_result(result)
+        return run_async_from_sync(self.aio_result)
 
 
 class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):

hatchet_sdk/utils/aio.py

@@ -0,0 +1,43 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Coroutine, ParamSpec, TypeVar
+
+P = ParamSpec("P")
+R = TypeVar("R")
+Y = TypeVar("Y")
+S = TypeVar("S")
+
+
+def _run_async_function_do_not_use_directly(
+    async_func: Callable[P, Coroutine[Y, S, R]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> R:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(async_func(*args, **kwargs))
+    finally:
+        loop.close()
+
+
+def run_async_from_sync(
+    async_func: Callable[P, Coroutine[Y, S, R]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> R:
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        return loop.run_until_complete(async_func(*args, **kwargs))
+    else:
+        with ThreadPoolExecutor() as executor:
+            future = executor.submit(
+                lambda: _run_async_function_do_not_use_directly(
+                    async_func, *args, **kwargs
+                )
+            )
+            return future.result()

hatchet_sdk/worker/runner/run_loop_manager.py

@@ -60,7 +60,7 @@ class WorkerActionRunLoopManager:
 
     async def aio_start(self, retry_count: int = 1) -> None:
         await capture_logs(
-            self.client.logInterceptor,
+            self.client.log_interceptor,
             self.client.event,
             self._async_start,
         )(retry_count=retry_count)

hatchet_sdk/workflow_run.py

@@ -1,4 +1,3 @@
-import asyncio
 from typing import Any
 
 from hatchet_sdk.clients.run_event_listener import (
@@ -6,19 +5,19 @@ from hatchet_sdk.clients.run_event_listener import (
     RunEventListenerClient,
 )
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
-from hatchet_sdk.utils.aio_utils import get_active_event_loop
+from hatchet_sdk.config import ClientConfig
+from hatchet_sdk.utils.aio import run_async_from_sync
 
 
 class WorkflowRunRef:
     def __init__(
         self,
         workflow_run_id: str,
-        workflow_listener: PooledWorkflowRunListener,
-        workflow_run_event_listener: RunEventListenerClient,
+        config: ClientConfig,
     ):
         self.workflow_run_id = workflow_run_id
-        self.workflow_listener = workflow_listener
-        self.workflow_run_event_listener = workflow_run_event_listener
+        self.workflow_listener = PooledWorkflowRunListener(config)
+        self.workflow_run_event_listener = RunEventListenerClient(config=config)
 
     def __str__(self) -> str:
         return self.workflow_run_id
@@ -27,19 +26,7 @@ class WorkflowRunRef:
         return self.workflow_run_event_listener.stream(self.workflow_run_id)
 
     async def aio_result(self) -> dict[str, Any]:
-        return await self.workflow_listener.result(self.workflow_run_id)
+        return await self.workflow_listener.aio_result(self.workflow_run_id)
 
     def result(self) -> dict[str, Any]:
-        coro = self.workflow_listener.result(self.workflow_run_id)
-
-        loop = get_active_event_loop()
-
-        if loop is None:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                return loop.run_until_complete(coro)
-            finally:
-                asyncio.set_event_loop(None)
-        else:
-            return loop.run_until_complete(coro)
+        return run_async_from_sync(self.aio_result)

{hatchet_sdk-1.0.2.dist-info → hatchet_sdk-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.0.2
+Version: 1.1.0
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run