hatchet-sdk 1.12.3__py3-none-any.whl → 1.13.0__py3-none-any.whl

hatchet_sdk/__init__.py

@@ -1,5 +1,4 @@
 from hatchet_sdk.clients.admin import (
-    DedupeViolationErr,
     ScheduleTriggerWorkflowOptions,
     TriggerWorkflowOptions,
 )
@@ -138,6 +137,11 @@ from hatchet_sdk.contracts.workflows_pb2 import (
     RateLimitDuration,
     WorkerLabelComparator,
 )
+from hatchet_sdk.exceptions import (
+    DedupeViolationError,
+    FailedTaskRunExceptionGroup,
+    TaskRunError,
+)
 from hatchet_sdk.features.runs import BulkCancelReplayOpts, RunFilter
 from hatchet_sdk.hatchet import Hatchet
 from hatchet_sdk.runnables.task import Task
@@ -162,7 +166,6 @@ from hatchet_sdk.waits import (
 from hatchet_sdk.worker.worker import Worker, WorkerStartOptions, WorkerStatus
 
 __all__ = [
-    "AcceptInviteRequest",
     "APIError",
     "APIErrors",
     "APIMeta",
@@ -170,11 +173,24 @@ __all__ = [
     "APIMetaIntegration",
     "APIResourceMeta",
     "APIToken",
+    "AcceptInviteRequest",
+    "BulkCancelReplayOpts",
+    "ClientConfig",
+    "ClientTLSConfig",
+    "ConcurrencyExpression",
+    "ConcurrencyLimitStrategy",
+    "Condition",
+    "Context",
     "CreateAPITokenRequest",
     "CreateAPITokenResponse",
     "CreatePullRequestFromStepRun",
     "CreateTenantInviteRequest",
     "CreateTenantRequest",
+    "CreateWorkflowVersionOpts",
+    "DedupeViolationError",
+    "DefaultFilter",
+    "DurableContext",
+    "EmptyModel",
     "Event",
     "EventData",
     "EventKeyList",
@@ -182,10 +198,12 @@ __all__ = [
     "EventOrderByDirection",
     "EventOrderByField",
     "EventWorkflowRunSummary",
+    "FailedTaskRunExceptionGroup",
     "GetStepRunDiffResponse",
     "GithubAppInstallation",
     "GithubBranch",
     "GithubRepo",
+    "Hatchet",
     "Job",
     "JobRun",
     "JobRunStatus",
@@ -198,15 +216,30 @@ __all__ = [
     "LogLineList",
     "LogLineOrderByDirection",
     "LogLineOrderByField",
+    "OTelAttribute",
+    "OpenTelemetryConfig",
+    "OrGroup",
     "PaginationResponse",
+    "ParentCondition",
     "PullRequest",
     "PullRequestState",
+    "PushEventOptions",
+    "RateLimitDuration",
+    "RegisterDurableEventRequest",
     "RejectInviteRequest",
     "ReplayEventRequest",
     "RerunStepRunRequest",
+    "RunFilter",
+    "ScheduleTriggerWorkflowOptions",
+    "SleepCondition",
     "StepRun",
     "StepRunDiff",
+    "StepRunEventType",
     "StepRunStatus",
+    "StickyStrategy",
+    "Task",
+    "TaskDefaults",
+    "TaskRunError",
     "Tenant",
     "TenantInvite",
     "TenantInviteList",
@@ -214,20 +247,30 @@ __all__ = [
     "TenantMember",
     "TenantMemberList",
     "TenantMemberRole",
+    "TriggerWorkflowOptions",
     "TriggerWorkflowRunRequest",
     "UpdateTenantInviteRequest",
     "User",
+    "UserEventCondition",
     "UserLoginRequest",
     "UserRegisterRequest",
     "UserTenantMembershipsList",
     "UserTenantPublic",
+    "V1TaskStatus",
+    "Worker",
     "Worker",
+    "WorkerContext",
     "WorkerLabelComparator",
     "WorkerList",
+    "WorkerStartOptions",
+    "WorkerStatus",
+    "Workflow",
     "Workflow",
+    "WorkflowConfig",
     "WorkflowDeploymentConfig",
     "WorkflowList",
     "WorkflowRun",
+    "WorkflowRunEventType",
     "WorkflowRunList",
     "WorkflowRunStatus",
     "WorkflowRunTriggeredBy",
@@ -238,43 +281,6 @@ __all__ = [
     "WorkflowVersion",
     "WorkflowVersionDefinition",
     "WorkflowVersionMeta",
-    "ConcurrencyLimitStrategy",
-    "CreateWorkflowVersionOpts",
-    "RateLimitDuration",
-    "StickyStrategy",
-    "DedupeViolationErr",
-    "ScheduleTriggerWorkflowOptions",
-    "TriggerWorkflowOptions",
-    "PushEventOptions",
-    "StepRunEventType",
-    "WorkflowRunEventType",
-    "Context",
-    "WorkerContext",
-    "ClientConfig",
-    "Hatchet",
-    "workflow",
-    "Worker",
-    "WorkerStartOptions",
-    "WorkerStatus",
-    "ConcurrencyExpression",
-    "Workflow",
-    "WorkflowConfig",
-    "Task",
-    "EmptyModel",
-    "Condition",
-    "OrGroup",
     "or_",
-    "SleepCondition",
-    "UserEventCondition",
-    "ParentCondition",
-    "DurableContext",
-    "RegisterDurableEventRequest",
-    "TaskDefaults",
-    "BulkCancelReplayOpts",
-    "RunFilter",
-    "V1TaskStatus",
-    "OTelAttribute",
-    "OpenTelemetryConfig",
-    "ClientTLSConfig",
-    "DefaultFilter",
+    "workflow",
 ]

hatchet_sdk/clients/admin.py

@@ -1,7 +1,8 @@
 import asyncio
 import json
+from collections.abc import Generator
 from datetime import datetime
-from typing import Generator, TypeVar, Union, cast
+from typing import TypeVar, cast
 
 import grpc
 from google.protobuf import timestamp_pb2
@@ -16,6 +17,7 @@ from hatchet_sdk.contracts import workflows_pb2 as v0_workflow_protos
 from hatchet_sdk.contracts.v1 import workflows_pb2 as workflow_protos
 from hatchet_sdk.contracts.v1.workflows_pb2_grpc import AdminServiceStub
 from hatchet_sdk.contracts.workflows_pb2_grpc import WorkflowServiceStub
+from hatchet_sdk.exceptions import DedupeViolationError
 from hatchet_sdk.features.runs import RunsClient
 from hatchet_sdk.metadata import get_metadata
 from hatchet_sdk.rate_limit import RateLimitDuration
@@ -59,12 +61,6 @@ class WorkflowRunTriggerConfig(BaseModel):
     key: str | None = None
 
 
-class DedupeViolationErr(Exception):
-    """Raised by the Hatchet library to indicate that a workflow has already been run with this deduplication value."""
-
-    pass
-
-
 class AdminClient:
     def __init__(
         self,
@@ -113,7 +109,7 @@ class AdminClient:
             try:
                 return json.dumps(v).encode("utf-8")
             except json.JSONDecodeError as e:
-                raise ValueError(f"Error encoding payload: {e}")
+                raise ValueError("Error encoding payload") from e
 
     def _prepare_workflow_request(
         self,
@@ -124,7 +120,7 @@ class AdminClient:
         try:
             payload_data = json.dumps(input)
         except json.JSONDecodeError as e:
-            raise ValueError(f"Error encoding payload: {e}")
+            raise ValueError("Error encoding payload") from e
 
         _options = self.TriggerWorkflowRequest.model_validate(options.model_dump())
 
@@ -148,18 +144,17 @@ class AdminClient:
             seconds = int(t)
             nanos = int(t % 1 * 1e9)
             return timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
-        elif isinstance(schedule, timestamp_pb2.Timestamp):
+        if isinstance(schedule, timestamp_pb2.Timestamp):
             return schedule
-        else:
-            raise ValueError(
-                "Invalid schedule type. Must be datetime or timestamp_pb2.Timestamp."
-            )
+        raise ValueError(
+            "Invalid schedule type. Must be datetime or timestamp_pb2.Timestamp."
+        )
 
     def _prepare_schedule_workflow_request(
         self,
         name: str,
-        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
-        input: JSONSerializableMapping = {},
+        schedules: list[datetime | timestamp_pb2.Timestamp],
+        input: JSONSerializableMapping | None = None,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> v0_workflow_protos.ScheduleWorkflowRequest:
         return v0_workflow_protos.ScheduleWorkflowRequest(
@@ -194,8 +189,8 @@ class AdminClient:
     async def aio_schedule_workflow(
         self,
         name: str,
-        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
-        input: JSONSerializableMapping = {},
+        schedules: list[datetime | timestamp_pb2.Timestamp],
+        input: JSONSerializableMapping | None = None,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> v0_workflow_protos.WorkflowVersion:
         return await asyncio.to_thread(
@@ -245,8 +240,8 @@ class AdminClient:
     def schedule_workflow(
         self,
         name: str,
-        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
-        input: JSONSerializableMapping = {},
+        schedules: list[datetime | timestamp_pb2.Timestamp],
+        input: JSONSerializableMapping | None = None,
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> v0_workflow_protos.WorkflowVersion:
         try:
@@ -269,7 +264,7 @@ class AdminClient:
             )
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise DedupeViolationErr(e.details())
+                raise DedupeViolationError(e.details()) from e
 
             raise e
 
@@ -336,7 +331,7 @@ class AdminClient:
             )
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise DedupeViolationErr(e.details())
+                raise DedupeViolationError(e.details()) from e
             raise e
 
         return WorkflowRunRef(
@@ -369,7 +364,7 @@ class AdminClient:
             )
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise DedupeViolationErr(e.details())
+                raise DedupeViolationError(e.details()) from e
 
             raise e
 

hatchet_sdk/clients/dispatcher/action_listener.py

@@ -1,7 +1,8 @@
 import asyncio
 import json
 import time
-from typing import TYPE_CHECKING, AsyncGenerator, cast
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, cast
 
 import grpc
 import grpc.aio
@@ -302,7 +303,7 @@ class ActionListener:
             )
             self.run_heartbeat = False
             raise Exception("retry_exhausted")
-        elif self.retries >= 1:
+        if self.retries >= 1:
             # logger.info
             # if we are retrying, we wait for a bit. this should eventually be replaced with exp backoff + jitter
             await exp_backoff_sleep(
@@ -369,4 +370,4 @@ class ActionListener:
 
             return cast(WorkerUnsubscribeRequest, req)
         except grpc.RpcError as e:
-            raise Exception(f"Failed to unsubscribe: {e}")
+            raise Exception("Failed to unsubscribe") from e

hatchet_sdk/clients/dispatcher/dispatcher.py

@@ -93,10 +93,7 @@ class DispatcherClient:
             )
         except Exception as e:
             # for step action events, send a failure event when we cannot send the completed event
-            if (
-                event_type == STEP_EVENT_TYPE_COMPLETED
-                or event_type == STEP_EVENT_TYPE_FAILED
-            ):
+            if event_type in (STEP_EVENT_TYPE_COMPLETED, STEP_EVENT_TYPE_FAILED):
                 await self._try_send_step_action_event(
                     action,
                     STEP_EVENT_TYPE_FAILED,

hatchet_sdk/clients/event_ts.py

@@ -1,5 +1,6 @@
 import asyncio
-from typing import Callable, Generic, TypeVar, cast, overload
+from collections.abc import Callable
+from typing import Generic, TypeVar, cast, overload
 
 import grpc.aio
 from grpc._cython import cygrpc  # type: ignore[attr-defined]

hatchet_sdk/clients/events.py

@@ -1,7 +1,7 @@
 import asyncio
 import datetime
 import json
-from typing import List, cast
+from typing import cast
 
 from google.protobuf import timestamp_pb2
 from pydantic import BaseModel, Field
@@ -88,7 +88,7 @@ class EventClient(BaseRestClient):
         self,
         events: list[BulkPushEventWithMetadata],
         options: BulkPushEventOptions = BulkPushEventOptions(),
-    ) -> List[Event]:
+    ) -> list[Event]:
         return await asyncio.to_thread(self.bulk_push, events=events, options=options)
 
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
@@ -105,12 +105,12 @@ class EventClient(BaseRestClient):
         try:
             meta_bytes = json.dumps(options.additional_metadata)
         except Exception as e:
-            raise ValueError(f"Error encoding meta: {e}")
+            raise ValueError("Error encoding meta") from e
 
         try:
             payload_str = json.dumps(payload)
         except (TypeError, ValueError) as e:
-            raise ValueError(f"Error encoding payload: {e}")
+            raise ValueError("Error encoding payload") from e
 
         request = PushEventRequest(
             key=namespaced_event_key,
@@ -139,12 +139,12 @@ class EventClient(BaseRestClient):
         try:
             meta_str = json.dumps(meta)
         except Exception as e:
-            raise ValueError(f"Error encoding meta: {e}")
+            raise ValueError("Error encoding meta") from e
 
         try:
             serialized_payload = json.dumps(payload)
         except (TypeError, ValueError) as e:
-            raise ValueError(f"Error serializing payload: {e}")
+            raise ValueError("Error serializing payload") from e
 
         return PushEventRequest(
             key=event_key,
@@ -159,9 +159,9 @@ class EventClient(BaseRestClient):
     @tenacity_retry
     def bulk_push(
         self,
-        events: List[BulkPushEventWithMetadata],
+        events: list[BulkPushEventWithMetadata],
         options: BulkPushEventOptions = BulkPushEventOptions(),
-    ) -> List[Event]:
+    ) -> list[Event]:
         namespace = options.namespace or self.namespace
 
         bulk_request = BulkPushEventRequest(
@@ -190,7 +190,7 @@ class EventClient(BaseRestClient):
         self.events_service_client.PutLog(request, metadata=get_metadata(self.token))
 
     @tenacity_retry
-    def stream(self, data: str | bytes, step_run_id: str) -> None:
+    def stream(self, data: str | bytes, step_run_id: str, index: int) -> None:
         if isinstance(data, str):
             data_bytes = data.encode("utf-8")
         elif isinstance(data, bytes):
@@ -202,11 +202,15 @@ class EventClient(BaseRestClient):
             stepRunId=step_run_id,
             createdAt=proto_timestamp_now(),
             message=data_bytes,
+            eventIndex=index,
         )
 
-        self.events_service_client.PutStreamEvent(
-            request, metadata=get_metadata(self.token)
-        )
+        try:
+            self.events_service_client.PutStreamEvent(
+                request, metadata=get_metadata(self.token)
+            )
+        except Exception:
+            raise
 
     async def aio_list(
         self,

hatchet_sdk/clients/listeners/durable_event_listener.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel, ConfigDict
 
 from hatchet_sdk.clients.listeners.pooled_listener import PooledListener
 from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
+from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.connection import new_conn
 from hatchet_sdk.contracts.v1.dispatcher_pb2 import (
     DurableEvent,
@@ -32,6 +33,7 @@ class RegisterDurableEventRequest(BaseModel):
     task_id: str
     signal_key: str
     conditions: list[SleepCondition | UserEventCondition]
+    config: ClientConfig
 
     def to_proto(self) -> RegisterDurableEventRequestProto:
         return RegisterDurableEventRequestProto(
@@ -39,12 +41,12 @@ class RegisterDurableEventRequest(BaseModel):
             signal_key=self.signal_key,
             conditions=DurableEventListenerConditions(
                 sleep_conditions=[
-                    c.to_proto()
+                    c.to_proto(self.config)
                     for c in self.conditions
                     if isinstance(c, SleepCondition)
                 ],
                 user_event_conditions=[
-                    c.to_proto()
+                    c.to_proto(self.config)
                     for c in self.conditions
                     if isinstance(c, UserEventCondition)
                 ],

hatchet_sdk/clients/listeners/pooled_listener.py

@@ -252,10 +252,10 @@ class PooledListener(Generic[R, T, L], ABC):
                     metadata=get_metadata(self.token),
                 )
 
-            except grpc.RpcError as e:
+            except grpc.RpcError as e:  # noqa: PERF203
                 if e.code() == grpc.StatusCode.UNAVAILABLE:
                     retries = retries + 1
                 else:
-                    raise ValueError(f"gRPC error: {e}")
+                    raise ValueError("gRPC error") from e
 
         raise ValueError("Failed to connect to listener")

hatchet_sdk/clients/listeners/run_event_listener.py

@@ -1,8 +1,9 @@
 import asyncio
+from collections.abc import AsyncGenerator, Callable, Generator
 from enum import Enum
 from queue import Empty, Queue
 from threading import Thread
-from typing import Any, AsyncGenerator, Callable, Generator, Literal, TypeVar, cast
+from typing import Any, Literal, TypeVar, cast
 
 import grpc
 from pydantic import BaseModel
@@ -129,8 +130,7 @@ class RunEventListener:
         thread.join()
 
     def __iter__(self) -> Generator[StepRunEvent, None, None]:
-        for item in self.async_to_sync_thread(self.__aiter__()):
-            yield item
+        yield from self.async_to_sync_thread(self.__aiter__())
 
     async def _generator(self) -> AsyncGenerator[StepRunEvent, None]:
         while True:
@@ -216,7 +216,7 @@ class RunEventListener:
                             metadata=get_metadata(self.config.token),
                         ),
                     )
-                elif self.additional_meta_kv is not None:
+                if self.additional_meta_kv is not None:
                     return cast(
                         AsyncGenerator[WorkflowEvent, None],
                         self.client.SubscribeToWorkflowEvents(
@@ -227,14 +227,13 @@ class RunEventListener:
                             metadata=get_metadata(self.config.token),
                         ),
                     )
-                else:
-                    raise Exception("no listener method provided")
+                raise Exception("no listener method provided")
 
-            except grpc.RpcError as e:
+            except grpc.RpcError as e:  # noqa: PERF203
                 if e.code() == grpc.StatusCode.UNAVAILABLE:
                     retries = retries + 1
                 else:
-                    raise ValueError(f"gRPC error: {e}")
+                    raise ValueError("gRPC error") from e
 
         raise Exception("Failed to subscribe to workflow events")
 

hatchet_sdk/clients/listeners/workflow_listener.py

@@ -1,5 +1,6 @@
 import json
-from typing import Any, AsyncIterator, cast
+from collections.abc import AsyncIterator
+from typing import Any, cast
 
 import grpc
 import grpc.aio
@@ -11,6 +12,11 @@ from hatchet_sdk.contracts.dispatcher_pb2 import (
     WorkflowRunEvent,
 )
 from hatchet_sdk.contracts.dispatcher_pb2_grpc import DispatcherStub
+from hatchet_sdk.exceptions import (
+    DedupeViolationError,
+    FailedTaskRunExceptionGroup,
+    TaskRunError,
+)
 
 DEDUPE_MESSAGE = "DUPLICATE_WORKFLOW_RUN"
 
@@ -27,16 +33,18 @@ class PooledWorkflowRunListener(
         return response.workflowRunId
 
     async def aio_result(self, id: str) -> dict[str, Any]:
-        from hatchet_sdk.clients.admin import DedupeViolationErr
-
         event = await self.subscribe(id)
         errors = [result.error for result in event.results if result.error]
+        workflow_run_id = event.workflowRunId
 
         if errors:
             if DEDUPE_MESSAGE in errors[0]:
-                raise DedupeViolationErr(errors[0])
-            else:
-                raise Exception(f"Workflow Errors: {errors}")
+                raise DedupeViolationError(errors[0])
+
+            raise FailedTaskRunExceptionGroup(
+                f"Workflow run {workflow_run_id} failed.",
+                [TaskRunError.deserialize(e) for e in errors],
+            )
 
         return {
             result.stepReadableId: json.loads(result.output)

hatchet_sdk/clients/rest/api_response.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Generic, Mapping, Optional, TypeVar
+from collections.abc import Mapping
+from typing import Generic, TypeVar
 
 from pydantic import BaseModel, Field, StrictBytes, StrictInt
 
@@ -15,7 +16,7 @@ class ApiResponse(BaseModel, Generic[T]):
     """
 
     status_code: StrictInt = Field(description="HTTP status code")
-    headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+    headers: Mapping[str, str] | None = Field(None, description="HTTP headers")
     data: T = Field(description="Deserialized data given the data type")
     raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
 

hatchet_sdk/clients/rest/tenacity_utils.py

@@ -1,4 +1,5 @@
-from typing import Callable, ParamSpec, TypeVar
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar
 
 import grpc
 import tenacity
@@ -28,12 +29,9 @@ def tenacity_alert_retry(retry_state: tenacity.RetryCallState) -> None:
 
 
 def tenacity_should_retry(ex: BaseException) -> bool:
-    if isinstance(ex, (grpc.aio.AioRpcError, grpc.RpcError)):
-        if ex.code() in [
+    if isinstance(ex, grpc.aio.AioRpcError | grpc.RpcError):
+        return ex.code() not in [
             grpc.StatusCode.UNIMPLEMENTED,
             grpc.StatusCode.NOT_FOUND,
-        ]:
-            return False
-        return True
-    else:
-        return False
+        ]
+    return False

hatchet_sdk/config.py

@@ -82,6 +82,8 @@ class ClientConfig(BaseSettings):
     enable_force_kill_sync_threads: bool = False
     enable_thread_pool_monitoring: bool = False
 
+    terminate_worker_after_num_tasks: int | None = None
+
     @model_validator(mode="after")
     def validate_token_and_tenant(self) -> "ClientConfig":
         if not self.token:

hatchet_sdk/connection.py

@@ -22,7 +22,8 @@ def new_conn(config: ClientConfig, aio: bool) -> grpc.Channel | grpc.aio.Channel
         root: bytes | None = None
 
         if config.tls_config.root_ca_file:
-            root = open(config.tls_config.root_ca_file, "rb").read()
+            with open(config.tls_config.root_ca_file, "rb") as f:
+                root = f.read()
 
         credentials = grpc.ssl_channel_credentials(root_certificates=root)
     elif config.tls_config.strategy == "mtls":
@@ -30,9 +31,14 @@ def new_conn(config: ClientConfig, aio: bool) -> grpc.Channel | grpc.aio.Channel
         assert config.tls_config.key_file
         assert config.tls_config.cert_file
 
-        root = open(config.tls_config.root_ca_file, "rb").read()
-        private_key = open(config.tls_config.key_file, "rb").read()
-        certificate_chain = open(config.tls_config.cert_file, "rb").read()
+        with open(config.tls_config.root_ca_file, "rb") as f:
+            root = f.read()
+
+        with open(config.tls_config.key_file, "rb") as f:
+            private_key = f.read()
+
+        with open(config.tls_config.cert_file, "rb") as f:
+            certificate_chain = f.read()
 
         credentials = grpc.ssl_channel_credentials(
             root_certificates=root,