hatchet-sdk 0.46.1__tar.gz → 0.47.0__tar.gz

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 0.46.1
+Version: 0.47.0
 Summary: 
 Author: Alexander Belanger
 Author-email: alexander@hatchet.run
@@ -13,7 +13,7 @@ Provides-Extra: otel
 Requires-Dist: aiohttp (>=3.10.5,<4.0.0)
 Requires-Dist: aiohttp-retry (>=2.8.3,<3.0.0)
 Requires-Dist: aiostream (>=0.5.2,<0.6.0)
-Requires-Dist: cel-python (>=0.1.5,<0.2.0)
+Requires-Dist: cel-python (>=0.2.0,<0.3.0)
 Requires-Dist: grpcio (>=1.64.1,!=1.68.*) ; python_version < "3.13"
 Requires-Dist: grpcio (>=1.69.0) ; python_version >= "3.13"
 Requires-Dist: grpcio-tools (>=1.64.1,!=1.68.*) ; python_version < "3.13"

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/clients/workflow_listener.py

@@ -75,6 +75,12 @@ class PooledWorkflowRunListener:
     interrupter: asyncio.Task = None
 
     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)
         self.token = config.token
@@ -260,12 +266,10 @@ class PooledWorkflowRunListener:
                 if self.curr_requester != 0:
                     self.requests.put_nowait(self.curr_requester)
 
-                listener = self.client.SubscribeToWorkflowRuns(
+                return self.client.SubscribeToWorkflowRuns(
                     self._request(),
                     metadata=get_metadata(self.token),
                 )
-
-                return listener
             except grpc.RpcError as e:
                 if e.code() == grpc.StatusCode.UNAVAILABLE:
                     retries = retries + 1

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/context/context.py

@@ -403,3 +403,44 @@ class Context(BaseContext):
             for step_run in job_run.step_runs
             if step_run.error and step_run.step
         ]
+
+    @tenacity_retry
+    def spawn_workflow(
+        self,
+        workflow_name: str,
+        input: dict[str, Any] = {},
+        key: str | None = None,
+        options: ChildTriggerWorkflowOptions | None = None,
+    ) -> WorkflowRunRef:
+        worker_id = self.worker.id()
+        trigger_options = self._prepare_workflow_options(key, options, worker_id)
+
+        return self.admin_client.run_workflow(workflow_name, input, trigger_options)
+
+    @tenacity_retry
+    def spawn_workflows(
+        self, child_workflow_runs: list[ChildWorkflowRunDict]
+    ) -> list[WorkflowRunRef]:
+
+        if len(child_workflow_runs) == 0:
+            raise Exception("no child workflows to spawn")
+
+        worker_id = self.worker.id()
+
+        bulk_trigger_workflow_runs: list[WorkflowRunDict] = []
+        for child_workflow_run in child_workflow_runs:
+            workflow_name = child_workflow_run["workflow_name"]
+            input = child_workflow_run["input"]
+
+            key = child_workflow_run.get("key")
+            options = child_workflow_run.get("options", {})
+
+            trigger_options = self._prepare_workflow_options(key, options, worker_id)
+
+            bulk_trigger_workflow_runs.append(
+                WorkflowRunDict(
+                    workflow_name=workflow_name, input=input, options=trigger_options
+                )
+            )
+
+        return self.admin_client.run_workflows(bulk_trigger_workflow_runs)

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/loader.py

@@ -42,6 +42,7 @@ class ClientConfig:
         worker_healthcheck_port: int | None = None,
         worker_healthcheck_enabled: bool | None = None,
         worker_preset_labels: dict[str, str] = {},
+        enable_force_kill_sync_threads: bool = False,
     ):
         self.tenant_id = tenant_id
         self.tls_config = tls_config
@@ -55,6 +56,7 @@ class ClientConfig:
         self.worker_healthcheck_port = worker_healthcheck_port
         self.worker_healthcheck_enabled = worker_healthcheck_enabled
         self.worker_preset_labels = worker_preset_labels
+        self.enable_force_kill_sync_threads = enable_force_kill_sync_threads
 
         if not self.logInterceptor:
             self.logInterceptor = getLogger()
@@ -174,6 +176,14 @@ class ConfigLoader:
                 "The `otel_exporter_otlp_*` fields are no longer supported as of SDK version `0.46.0`. Please see the documentation on OpenTelemetry at https://docs.hatchet.run/home/features/opentelemetry for more information on how to migrate to the new `HatchetInstrumentor`."
             )
 
+        enable_force_kill_sync_threads = bool(
+            get_config_value(
+                "enable_force_kill_sync_threads",
+                "HATCHET_CLIENT_ENABLE_FORCE_KILL_SYNC_THREADS",
+            )
+            == "True"
+            or False
+        )
         return ClientConfig(
             tenant_id=tenant_id,
             tls_config=tls_config,
@@ -188,6 +198,7 @@ class ConfigLoader:
             worker_healthcheck_port=worker_healthcheck_port,
             worker_healthcheck_enabled=worker_healthcheck_enabled,
             worker_preset_labels=worker_preset_labels,
+            enable_force_kill_sync_threads=enable_force_kill_sync_threads,
         )
 
     def _load_tls_config(self, tls_data: Dict, host_port) -> ClientTLSConfig:

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/opentelemetry/instrumentor.py

@@ -13,6 +13,7 @@ try:
         StatusCode,
         TracerProvider,
         get_tracer,
+        get_tracer_provider,
     )
     from opentelemetry.trace.propagation.tracecontext import (
         TraceContextTextMapPropagator,
@@ -43,49 +44,121 @@ hatchet_sdk_version = version("hatchet-sdk")
 
 InstrumentKwargs = TracerProvider | MeterProvider | None
 
+OTEL_TRACEPARENT_KEY = "traceparent"
 
-class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
-    OTEL_TRACEPARENT_KEY = "traceparent"
 
-    def __init__(
-        self,
-        tracer_provider: TracerProvider,
-        meter_provider: MeterProvider = NoOpMeterProvider(),
-    ):
-        self.tracer_provider = tracer_provider
-        self.meter_provider = meter_provider
+def create_traceparent() -> str | None:
+    """
+    Creates and returns a W3C traceparent header value using OpenTelemetry's context propagation.
 
-        super().__init__()
+    The traceparent header is used to propagate context information across service boundaries
+    in distributed tracing systems. It follows the W3C Trace Context specification.
 
-    def create_traceparent(self) -> str | None:
-        carrier: dict[str, str] = {}
-        TraceContextTextMapPropagator().inject(carrier)
+    :returns: A W3C-formatted traceparent header value if successful, None if the context
+                    injection fails or no active span exists.\n
+                    Example: `00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01`
+    :rtype: str | None:
+    """
 
-        return carrier.get("traceparent")
+    carrier: dict[str, str] = {}
+    TraceContextTextMapPropagator().inject(carrier)
 
-    def parse_carrier_from_metadata(
-        self, metadata: dict[str, str] | None
-    ) -> Context | None:
-        if not metadata:
-            return None
+    return carrier.get("traceparent")
 
-        traceparent = metadata.get(self.OTEL_TRACEPARENT_KEY)
 
-        if not traceparent:
-            return None
+def parse_carrier_from_metadata(metadata: dict[str, str] | None) -> Context | None:
+    """
+    Parses OpenTelemetry trace context from a metadata dictionary.
 
-        return TraceContextTextMapPropagator().extract(
-            {self.OTEL_TRACEPARENT_KEY: traceparent}
-        )
+    Extracts the trace context from metadata using the W3C Trace Context format,
+    specifically looking for the `traceparent` header.
+
+    :param metadata: A dictionary containing metadata key-value pairs,
+                     potentially including the `traceparent` header. Can be None.
+    :type metadata: dict[str, str] | None
+    :returns: The extracted OpenTelemetry Context object if a valid `traceparent`
+              is found in the metadata, otherwise None.
+    :rtype: Context | None
+
+    :Example:
+
+    >>> metadata = {"traceparent": "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01"}
+    >>> context = parse_carrier_from_metadata(metadata)
+    """
+
+    if not metadata:
+        return None
+
+    traceparent = metadata.get(OTEL_TRACEPARENT_KEY)
+
+    if not traceparent:
+        return None
+
+    return TraceContextTextMapPropagator().extract({OTEL_TRACEPARENT_KEY: traceparent})
+
+
+def inject_traceparent_into_metadata(
+    metadata: dict[str, str], traceparent: str | None = None
+) -> dict[str, str]:
+    """
+    Injects OpenTelemetry `traceparent` into a metadata dictionary.
+
+    Takes a metadata dictionary and an optional `traceparent` string,
+    returning a new metadata dictionary with the `traceparent` added under the
+    `OTEL_TRACEPARENT_KEY`. If no `traceparent` is provided, it attempts to create one.
 
-    def inject_traceparent_into_metadata(
-        self, metadata: dict[str, str], traceparent: str | None
-    ) -> dict[str, str]:
-        if traceparent:
-            metadata[self.OTEL_TRACEPARENT_KEY] = traceparent
+    :param metadata: The metadata dictionary to inject the `traceparent` into.
+    :type metadata: dict[str, str]
+    :param traceparent: The `traceparent` string to inject. If None, attempts to use
+                        the current span.
+    :type traceparent: str | None, optional
+    :returns: A new metadata dictionary containing the original metadata plus
+              the injected `traceparent`, if one was available or could be created.
+    :rtype: dict[str, str]
 
+    :Example:
+
+    >>> metadata = {"key": "value"}
+    >>> new_metadata = inject_traceparent(metadata, "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01")
+    >>> print(new_metadata)
+    {"key": "value", "traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"}
+    """
+
+    if not traceparent:
+        traceparent = create_traceparent()
+
+    if not traceparent:
         return metadata
 
+    return {
+        **metadata,
+        OTEL_TRACEPARENT_KEY: traceparent,
+    }
+
+
+class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
+    def __init__(
+        self,
+        tracer_provider: TracerProvider | None = None,
+        meter_provider: MeterProvider | None = None,
+    ):
+        """
+        Hatchet OpenTelemetry instrumentor.
+
+        The instrumentor provides an OpenTelemetry integration for Hatchet by setting up
+        tracing and metrics collection.
+
+        :param tracer_provider: TracerProvider | None: The OpenTelemetry TracerProvider to use.
+                If not provided, the global tracer provider will be used.
+        :param meter_provider: MeterProvider | None: The OpenTelemetry MeterProvider to use.
+                If not provided, a no-op meter provider will be used.
+        """
+
+        self.tracer_provider = tracer_provider or get_tracer_provider()
+        self.meter_provider = meter_provider or NoOpMeterProvider()
+
+        super().__init__()
+
     def instrumentation_dependencies(self) -> Collection[str]:
         return tuple()
 
@@ -154,7 +227,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         kwargs: Any,
     ) -> Exception | None:
         action = args[0]
-        traceparent = self.parse_carrier_from_metadata(action.additional_metadata)
+        traceparent = parse_carrier_from_metadata(action.additional_metadata)
 
         with self._tracer.start_as_current_span(
             "hatchet.start_step_run",

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/utils/aio_utils.py

@@ -92,7 +92,7 @@ class EventLoopThread:
         self.loop = asyncio.new_event_loop()
         self.thread = Thread(target=self.run_loop_in_thread, args=(self.loop,))
 
-    def __enter__(self) -> asyncio.AbstractEventLoop:
+    def __enter__(self, *a, **kw) -> asyncio.AbstractEventLoop:
         """
         Starts the thread running the event loop when entering the context.
 
@@ -102,7 +102,7 @@ class EventLoopThread:
         self.thread.start()
         return self.loop
 
-    def __exit__(self) -> None:
+    def __exit__(self, *a, **kw) -> None:
         """
         Stops the event loop and joins the thread when exiting the context.
         """

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/worker/runner/runner.py

@@ -3,12 +3,13 @@ import contextvars
 import ctypes
 import functools
 import json
+import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor
 from enum import Enum
 from multiprocessing import Queue
 from threading import Thread, current_thread
-from typing import Any, Callable, Dict, Literal, Type, TypeVar, cast, overload
+from typing import Any, Callable, Dict, cast
 
 from pydantic import BaseModel
 
@@ -421,6 +422,11 @@ class Runner:
 
             # check if thread is still running, if so, print a warning
             if run_id in self.threads:
+                thread = self.threads.get(run_id)
+                if thread and self.client.config.enable_force_kill_sync_threads:
+                    self.force_kill_thread(thread)
+                    await asyncio.sleep(1)
+
                 logger.warning(
                     f"Thread {self.threads[run_id].ident} with run id {run_id} is still running after cancellation. This could cause the thread pool to get blocked and prevent new tasks from running."
                 )

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/hatchet_sdk/workflow_run.py

@@ -32,16 +32,18 @@ class WorkflowRunRef:
         return self.workflow_listener.result(self.workflow_run_id)
 
     def sync_result(self) -> dict:
+        coro = self.workflow_listener.result(self.workflow_run_id)
         loop = get_active_event_loop()
+
         if loop is None:
-            with EventLoopThread() as loop:
-                coro = self.workflow_listener.result(self.workflow_run_id)
-                future = asyncio.run_coroutine_threadsafe(coro, loop)
-                return future.result()
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                return loop.run_until_complete(coro)
+            finally:
+                asyncio.set_event_loop(None)
         else:
-            coro = self.workflow_listener.result(self.workflow_run_id)
-            future = asyncio.run_coroutine_threadsafe(coro, loop)
-            return future.result()
+            return loop.run_until_complete(coro)
 
 
 T = TypeVar("T")

{hatchet_sdk-0.46.1 → hatchet_sdk-0.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hatchet-sdk"
-version = "0.46.1"
+version = "0.47.0"
 description = ""
 authors = ["Alexander Belanger <alexander@hatchet.run>"]
 readme = "README.md"
@@ -27,7 +27,7 @@ nest-asyncio = "^1.6.0"
 aiohttp = "^3.10.5"
 aiohttp-retry = "^2.8.3"
 tenacity = ">=8.4.1"
-cel-python = "^0.1.5"
+cel-python = "^0.2.0"
 opentelemetry-api = { version = "^1.28.0", optional = true }
 opentelemetry-sdk = { version = "^1.28.0", optional = true }
 opentelemetry-instrumentation = { version = ">=0.49b0", optional = true }
@@ -111,6 +111,7 @@ explicit_package_bases = true
 api = "examples.api.api:main"
 async = "examples.async.worker:main"
 fanout = "examples.fanout.worker:main"
+fanout_sync = "examples.fanout_sync.worker:main"
 cancellation = "examples.cancellation.worker:main"
 concurrency_limit = "examples.concurrency_limit.worker:main"
 concurrency_limit_rr = "examples.concurrency_limit_rr.worker:main"