hatchet-sdk 1.19.0__tar.gz → 1.20.0__tar.gz

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hatchet-sdk
-Version: 1.19.0
+Version: 1.20.0
 Summary: 
 License: MIT
 Author: Alexander Belanger

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/clients/dispatcher/action_listener.py

@@ -231,7 +231,6 @@ class ActionListener:
                         tenant_id=assigned_action.tenantId,
                         worker_id=self.worker_id,
                         workflow_run_id=assigned_action.workflowRunId,
-                        get_group_key_run_id=assigned_action.getGroupKeyRunId,
                         job_id=assigned_action.jobId,
                         job_name=assigned_action.jobName,
                         job_run_id=assigned_action.jobRunId,

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/clients/dispatcher/dispatcher.py

@@ -18,8 +18,6 @@ from hatchet_sdk.contracts.dispatcher_pb2 import (
     STEP_EVENT_TYPE_COMPLETED,
     STEP_EVENT_TYPE_FAILED,
     ActionEventResponse,
-    GroupKeyActionEvent,
-    GroupKeyActionEventType,
     OverridesData,
     RefreshTimeoutRequest,
     ReleaseSlotRequest,
@@ -151,34 +149,6 @@ class DispatcherClient:
             ),
         )
 
-    async def send_group_key_action_event(
-        self, action: Action, event_type: GroupKeyActionEventType, payload: str
-    ) -> grpc.aio.UnaryUnaryCall[GroupKeyActionEvent, ActionEventResponse]:
-        if not self.aio_client:
-            aio_conn = new_conn(self.config, True)
-            self.aio_client = DispatcherStub(aio_conn)
-
-        event_timestamp = Timestamp()
-        event_timestamp.GetCurrentTime()
-
-        event = GroupKeyActionEvent(
-            workerId=action.worker_id,
-            workflowRunId=action.workflow_run_id,
-            getGroupKeyRunId=action.get_group_key_run_id,
-            actionId=action.action_id,
-            eventTimestamp=event_timestamp,
-            eventType=event_type,
-            eventPayload=payload,
-        )
-
-        return cast(
-            grpc.aio.UnaryUnaryCall[GroupKeyActionEvent, ActionEventResponse],
-            await self.aio_client.SendGroupKeyActionEvent(
-                event,
-                metadata=get_metadata(self.token),
-            ),
-        )
-
     def put_overrides_data(self, data: OverridesData) -> ActionEventResponse:
         client = self._get_or_create_client()
 

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/hatchet.py

@@ -2,7 +2,6 @@ import asyncio
 import logging
 from collections.abc import Callable
 from datetime import timedelta
-from functools import cached_property
 from typing import Any, Concatenate, ParamSpec, cast, overload
 
 from hatchet_sdk import Context, DurableContext
@@ -10,7 +9,6 @@ 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.listeners.run_event_listener import RunEventListenerClient
-from hatchet_sdk.clients.rest.models.tenant_version import TenantVersion
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.features.cel import CELClient
 from hatchet_sdk.features.cron import CronClient
@@ -65,11 +63,6 @@ class Hatchet:
             client if client else Client(config=config or ClientConfig(), debug=debug)
         )
 
-        if self.tenant_engine_version != TenantVersion.V1:
-            logger.warning(
-                "🚨⚠️‼️ YOU ARE USING A V0 ENGINE WITH A V1 SDK, WHICH IS NOT SUPPORTED. PLEASE UPGRADE YOUR ENGINE TO V1.🚨⚠️‼️"
-            )
-
     @property
     def cel(self) -> CELClient:
         """
@@ -179,19 +172,6 @@ class Hatchet:
         """
         return self._client.config.namespace
 
-    @cached_property
-    def tenant_engine_version(self) -> TenantVersion:
-        """
-        Get the version of the Hatchet engine running in your tenant.
-        """
-        try:
-            return self._client.tenant.get().version
-        except Exception:
-            ## Nothing we can do here - if this fails, it's probably
-            ## because they don't have this endpoint yet, so we need to just
-            ## assume V1 to swallow the warning.
-            return TenantVersion.V1
-
     def worker(
         self,
         name: str,

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/opentelemetry/instrumentor.py

@@ -216,11 +216,7 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
             "worker.runner.runner.Runner.handle_start_step_run",
             self._wrap_handle_start_step_run,
         )
-        wrap_function_wrapper(
-            hatchet_sdk,
-            "worker.runner.runner.Runner.handle_start_group_key_run",
-            self._wrap_handle_get_group_key_run,
-        )
+
         wrap_function_wrapper(
             hatchet_sdk,
             "worker.runner.runner.Runner.handle_cancel_action",
@@ -310,27 +306,6 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
 
             return result
 
-    ## IMPORTANT: Keep these types in sync with the wrapped method's signature
-    async def _wrap_handle_get_group_key_run(
-        self,
-        wrapped: Callable[[Action], Coroutine[None, None, Exception | None]],
-        instance: Runner,
-        args: tuple[Action],
-        kwargs: Any,
-    ) -> Exception | None:
-        action = args[0]
-
-        with self._tracer.start_as_current_span(
-            "hatchet.get_group_key_run",
-            attributes=action.get_otel_attributes(self.config),
-        ) as span:
-            result = await wrapped(*args, **kwargs)
-
-            if isinstance(result, Exception):
-                span.set_status(StatusCode.ERROR, str(result))
-
-            return result
-
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     async def _wrap_handle_cancel_action(
         self,
@@ -719,7 +694,6 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
         self.meter_provider = NoOpMeterProvider()
 
         unwrap(hatchet_sdk, "worker.runner.runner.Runner.handle_start_step_run")
-        unwrap(hatchet_sdk, "worker.runner.runner.Runner.handle_start_group_key_run")
         unwrap(hatchet_sdk, "worker.runner.runner.Runner.handle_cancel_action")
         unwrap(hatchet_sdk, "clients.events.EventClient.push")
         unwrap(hatchet_sdk, "clients.events.EventClient.bulk_push")

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/runnables/action.py

@@ -49,16 +49,16 @@ class ActionPayload(BaseModel):
 class ActionType(str, Enum):
     START_STEP_RUN = "START_STEP_RUN"
     CANCEL_STEP_RUN = "CANCEL_STEP_RUN"
-    START_GET_GROUP_KEY = "START_GET_GROUP_KEY"
 
 
 class Action(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
     worker_id: str
     tenant_id: str
     workflow_run_id: str
     workflow_id: str | None = None
     workflow_version_id: str | None = None
-    get_group_key_run_id: str
     job_id: str
     job_name: str
     job_run_id: str
@@ -101,7 +101,6 @@ class Action(BaseModel):
             OTelAttribute.ACTION_PAYLOAD: payload_str,
             OTelAttribute.WORKFLOW_NAME: self.job_name,
             OTelAttribute.ACTION_NAME: self.action_id,
-            OTelAttribute.GET_GROUP_KEY_RUN_ID: self.get_group_key_run_id,
             OTelAttribute.WORKFLOW_ID: self.workflow_id,
             OTelAttribute.WORKFLOW_VERSION_ID: self.workflow_version_id,
         }
@@ -119,6 +118,4 @@ class Action(BaseModel):
         It's used when storing references to a task, a context, etc. in a dictionary so that
         we can look up those items in the dictionary by a unique key.
         """
-        if self.action_type == ActionType.START_GET_GROUP_KEY:
-            return f"{self.get_group_key_run_id}/{self.retry_count}"
         return f"{self.step_run_id}/{self.retry_count}"

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/runnables/task.py

@@ -299,7 +299,6 @@ class Task(Generic[TWorkflowInput, R]):
             tenant_id=self.workflow.client.config.tenant_id,
             worker_id="mock-worker-id",
             workflow_run_id="mock-workflow-run-id",
-            get_group_key_run_id="mock-get-group-key-run-id",
             job_id="mock-job-id",
             job_name="mock-job-name",
             job_run_id="mock-job-run-id",

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/utils/opentelemetry.py

@@ -16,7 +16,6 @@ class OTelAttribute(str, Enum):
     ACTION_NAME = "action_name"
     CHILD_WORKFLOW_INDEX = "child_workflow_index"
     CHILD_WORKFLOW_KEY = "child_workflow_key"
-    GET_GROUP_KEY_RUN_ID = "get_group_key_run_id"
     PARENT_WORKFLOW_RUN_ID = "parent_workflow_run_id"
     RETRY_COUNT = "retry_count"
     STEP_ID = "step_id"

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/worker/action_listener_process.py

@@ -18,10 +18,8 @@ from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
 from hatchet_sdk.clients.rest.models.update_worker_request import UpdateWorkerRequest
 from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.contracts.dispatcher_pb2 import (
-    GROUP_KEY_EVENT_TYPE_STARTED,
     STEP_EVENT_TYPE_STARTED,
     ActionEventResponse,
-    GroupKeyActionEvent,
     StepActionEvent,
 )
 from hatchet_sdk.logger import logger
@@ -80,11 +78,6 @@ class WorkerActionListenerProcess:
         self.step_action_events: set[
             asyncio.Task[UnaryUnaryCall[StepActionEvent, ActionEventResponse] | None]
         ] = set()
-        self.group_key_action_events: set[
-            asyncio.Task[
-                UnaryUnaryCall[GroupKeyActionEvent, ActionEventResponse] | None
-            ]
-        ] = set()
 
         if self.debug:
             logger.setLevel(logging.DEBUG)
@@ -213,16 +206,6 @@ class WorkerActionListenerProcess:
                     )
                 case ActionType.CANCEL_STEP_RUN:
                     logger.debug("unimplemented event send")
-                case ActionType.START_GET_GROUP_KEY:
-                    get_group_key_task = asyncio.create_task(
-                        self.dispatcher_client.send_group_key_action_event(
-                            event.action, event.type, event.payload
-                        )
-                    )
-                    self.group_key_action_events.add(get_group_key_task)
-                    get_group_key_task.add_done_callback(
-                        lambda t: self.group_key_action_events.discard(t)
-                    )
                 case _:
                     logger.error("unknown action type for event send")
         except Exception:
@@ -273,18 +256,6 @@ class WorkerActionListenerProcess:
 
                     case ActionType.CANCEL_STEP_RUN:
                         logger.info(f"rx: cancel step run: {action.step_run_id}")
-                    case ActionType.START_GET_GROUP_KEY:
-                        self.event_queue.put(
-                            ActionEvent(
-                                action=action,
-                                type=GROUP_KEY_EVENT_TYPE_STARTED,  # TODO ack type
-                                payload="",
-                                should_not_retry=False,
-                            )
-                        )
-                        logger.info(
-                            f"rx: start group key: {action.get_group_key_run_id}"
-                        )
                     case _:
                         logger.error(
                             f"rx: unknown action type ({action.action_type}): {action.action_type}"

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/hatchet_sdk/worker/runner/runner.py

@@ -23,9 +23,6 @@ from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.context.worker_context import WorkerContext
 from hatchet_sdk.contracts.dispatcher_pb2 import (
-    GROUP_KEY_EVENT_TYPE_COMPLETED,
-    GROUP_KEY_EVENT_TYPE_FAILED,
-    GROUP_KEY_EVENT_TYPE_STARTED,
     STEP_EVENT_TYPE_COMPLETED,
     STEP_EVENT_TYPE_FAILED,
     STEP_EVENT_TYPE_STARTED,
@@ -142,10 +139,6 @@ class Runner:
                 log = f"cancel: step run:  {action.action_id}/{action.step_run_id}/{action.retry_count}"
                 logger.info(log)
                 t = asyncio.create_task(self.handle_cancel_action(action))
-            case ActionType.START_GET_GROUP_KEY:
-                log = f"run: get group key:  {action.action_id}/{action.get_group_key_run_id}"
-                logger.info(log)
-                t = asyncio.create_task(self.handle_start_group_key_run(action))
             case _:
                 log = f"unknown action type: {action.action_type}"
                 logger.error(log)
@@ -218,67 +211,6 @@ class Runner:
 
         return inner_callback
 
-    def group_key_run_callback(
-        self, action: Action
-    ) -> Callable[[asyncio.Task[Any]], None]:
-        def inner_callback(task: asyncio.Task[Any]) -> None:
-            self.cleanup_run_id(action.key)
-
-            if task.cancelled():
-                return
-
-            try:
-                output = task.result()
-            except Exception as e:
-                exc = TaskRunError.from_exception(e, action.step_run_id)
-
-                self.event_queue.put(
-                    ActionEvent(
-                        action=action,
-                        type=GROUP_KEY_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(include_metadata=True),
-                        should_not_retry=False,
-                    )
-                )
-
-                logger.exception(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
-                )
-
-                return
-
-            try:
-                output = self.serialize_output(output)
-
-                self.event_queue.put(
-                    ActionEvent(
-                        action=action,
-                        type=GROUP_KEY_EVENT_TYPE_COMPLETED,
-                        payload=output,
-                        should_not_retry=False,
-                    )
-                )
-            except IllegalTaskOutputError as e:
-                exc = TaskRunError.from_exception(e, action.step_run_id)
-                self.event_queue.put(
-                    ActionEvent(
-                        action=action,
-                        type=STEP_EVENT_TYPE_FAILED,
-                        payload=exc.serialize(include_metadata=True),
-                        should_not_retry=False,
-                    )
-                )
-
-                logger.exception(
-                    f"failed step run: {action.action_id}/{action.step_run_id}\n{exc.serialize(include_metadata=False)}"
-                )
-
-                return
-
-            logger.info(f"finished step run: {action.action_id}/{action.step_run_id}")
-
-        return inner_callback
-
     def thread_action_func(
         self,
         ctx: Context,
@@ -286,7 +218,7 @@ class Runner:
         action: Action,
         dependencies: dict[str, Any],
     ) -> R:
-        if action.step_run_id or action.get_group_key_run_id:
+        if action.step_run_id:
             self.threads[action.key] = current_thread()
 
         return task.call(ctx, dependencies)
@@ -485,42 +417,6 @@ class Runner:
 
         return None
 
-    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
-    async def handle_start_group_key_run(self, action: Action) -> Exception | None:
-        action_name = action.action_id
-        context = self.create_context(action)
-
-        self.contexts[action.key] = context
-
-        # Find the corresponding action function from the registry
-        action_func = self.action_registry.get(action_name)
-
-        if action_func:
-            # send an event that the group key run has started
-            self.event_queue.put(
-                ActionEvent(
-                    action=action,
-                    type=GROUP_KEY_EVENT_TYPE_STARTED,
-                    payload="",
-                    should_not_retry=False,
-                )
-            )
-
-            loop = asyncio.get_event_loop()
-            task = loop.create_task(
-                self.async_wrapped_action_func(context, action_func, action)
-            )
-
-            task.add_done_callback(self.group_key_run_callback(action))
-            self.tasks[action.key] = task
-
-            try:
-                await task
-            except Exception as e:
-                return e
-
-        return None
-
     def force_kill_thread(self, thread: Thread) -> None:
         """Terminate a python threading.Thread."""
         try:

{hatchet_sdk-1.19.0 → hatchet_sdk-1.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hatchet-sdk"
-version = "1.19.0"
+version = "1.20.0"
 description = ""
 authors = ["Alexander Belanger <alexander@hatchet.run>"]
 readme = "README.md"