hatchet-sdk 0.47.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

hatchet_sdk/connection.py

@@ -1,26 +1,36 @@
 import os
-from typing import TYPE_CHECKING, Any
+from typing import Literal, cast, overload
 
 import grpc
 
-if TYPE_CHECKING:
-    from hatchet_sdk.loader import ClientConfig
+from hatchet_sdk.config import ClientConfig
 
 
-def new_conn(config: "ClientConfig", aio=False):
+@overload
+def new_conn(config: ClientConfig, aio: Literal[False]) -> grpc.Channel: ...
 
+
+@overload
+def new_conn(config: ClientConfig, aio: Literal[True]) -> grpc.aio.Channel: ...
+
+
+def new_conn(config: ClientConfig, aio: bool) -> grpc.Channel | grpc.aio.Channel:
     credentials: grpc.ChannelCredentials | None = None
 
     # load channel credentials
-    if config.tls_config.tls_strategy == "tls":
-        root: Any | None = None
+    if config.tls_config.strategy == "tls":
+        root: bytes | None = None
 
-        if config.tls_config.ca_file:
-            root = open(config.tls_config.ca_file, "rb").read()
+        if config.tls_config.root_ca_file:
+            root = open(config.tls_config.root_ca_file, "rb").read()
 
         credentials = grpc.ssl_channel_credentials(root_certificates=root)
-    elif config.tls_config.tls_strategy == "mtls":
-        root = open(config.tls_config.ca_file, "rb").read()
+    elif config.tls_config.strategy == "mtls":
+        assert config.tls_config.root_ca_file
+        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()
 
@@ -32,7 +42,7 @@ def new_conn(config: "ClientConfig", aio=False):
 
     start = grpc if not aio else grpc.aio
 
-    channel_options = [
+    channel_options: list[tuple[str, str | int]] = [
         ("grpc.max_send_message_length", config.grpc_max_send_message_length),
         ("grpc.max_receive_message_length", config.grpc_max_recv_message_length),
         ("grpc.keepalive_time_ms", 10 * 1000),
@@ -46,7 +56,7 @@ def new_conn(config: "ClientConfig", aio=False):
     # When steps execute via os.fork, we see `TSI_DATA_CORRUPTED` errors.
     os.environ["GRPC_ENABLE_FORK_SUPPORT"] = "False"
 
-    if config.tls_config.tls_strategy == "none":
+    if config.tls_config.strategy == "none":
         conn = start.insecure_channel(
             target=config.host_port,
             options=channel_options,
@@ -61,4 +71,8 @@ def new_conn(config: "ClientConfig", aio=False):
             credentials=credentials,
             options=channel_options,
         )
-    return conn
+
+    return cast(
+        grpc.Channel | grpc.aio.Channel,
+        conn,
+    )

hatchet_sdk/context/__init__.py

@@ -1 +0,0 @@
-from .context import Context

hatchet_sdk/context/context.py

@@ -2,42 +2,36 @@ import inspect
 import json
 import traceback
 from concurrent.futures import Future, ThreadPoolExecutor
-from typing import Any, Generic, Type, TypeVar, cast, overload
-from warnings import warn
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any, cast
 
-from pydantic import BaseModel, StrictStr
+from pydantic import BaseModel
 
+from hatchet_sdk.clients.admin import AdminClient
+from hatchet_sdk.clients.dispatcher.dispatcher import (  # type: ignore[attr-defined]
+    Action,
+    DispatcherClient,
+)
+from hatchet_sdk.clients.durable_event_listener import (
+    DurableEventListener,
+    RegisterDurableEventRequest,
+)
 from hatchet_sdk.clients.events import EventClient
-from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
 from hatchet_sdk.clients.rest_client import RestApi
 from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
 from hatchet_sdk.context.worker_context import WorkerContext
-from hatchet_sdk.contracts.dispatcher_pb2 import OverridesData
-from hatchet_sdk.contracts.workflows_pb2 import (
-    BulkTriggerWorkflowRequest,
-    TriggerWorkflowRequest,
-)
-from hatchet_sdk.utils.types import WorkflowValidator
-from hatchet_sdk.utils.typing import is_basemodel_subclass
-from hatchet_sdk.workflow_run import WorkflowRunRef
-
-from ..clients.admin import (
-    AdminClient,
-    ChildTriggerWorkflowOptions,
-    ChildWorkflowRunDict,
-    TriggerWorkflowOptions,
-    WorkflowRunDict,
-)
-from ..clients.dispatcher.dispatcher import (  # type: ignore[attr-defined]
-    Action,
-    DispatcherClient,
-)
-from ..logger import logger
+from hatchet_sdk.logger import logger
+from hatchet_sdk.utils.timedelta_to_expression import Duration, timedelta_to_expr
+from hatchet_sdk.utils.typing import JSONSerializableMapping, WorkflowValidator
+from hatchet_sdk.waits import SleepCondition, UserEventCondition
 
-DEFAULT_WORKFLOW_POLLING_INTERVAL = 5  # Seconds
+if TYPE_CHECKING:
+    from hatchet_sdk.runnables.task import Task
+    from hatchet_sdk.runnables.types import R, TWorkflowInput
 
-T = TypeVar("T", bound=BaseModel)
+
+DEFAULT_WORKFLOW_POLLING_INTERVAL = 5  # Seconds
 
 
 def get_caller_file_path() -> str:
@@ -46,43 +40,13 @@ def get_caller_file_path() -> str:
     return caller_frame.filename
 
 
-class BaseContext:
+class StepRunError(BaseModel):
+    step_id: str
+    step_run_action_name: str
+    error: str
 
-    action: Action
-    spawn_index: int
 
-    def _prepare_workflow_options(
-        self,
-        key: str | None = None,
-        options: ChildTriggerWorkflowOptions | None = None,
-        worker_id: str | None = None,
-    ) -> TriggerWorkflowOptions:
-        workflow_run_id = self.action.workflow_run_id
-        step_run_id = self.action.step_run_id
-
-        desired_worker_id = None
-        if options is not None and "sticky" in options and options["sticky"] == True:
-            desired_worker_id = worker_id
-
-        meta = None
-        if options is not None and "additional_metadata" in options:
-            meta = options["additional_metadata"]
-
-        ## TODO: Pydantic here to simplify this
-        trigger_options: TriggerWorkflowOptions = {
-            "parent_id": workflow_run_id,
-            "parent_step_run_id": step_run_id,
-            "child_key": key,
-            "child_index": self.spawn_index,
-            "additional_metadata": meta,
-            "desired_worker_id": desired_worker_id,
-        }
-
-        self.spawn_index += 1
-        return trigger_options
-
-
-class ContextAioImpl(BaseContext):
+class Context:
     def __init__(
         self,
         action: Action,
@@ -90,89 +54,8 @@ class ContextAioImpl(BaseContext):
         admin_client: AdminClient,
         event_client: EventClient,
         rest_client: RestApi,
-        workflow_listener: PooledWorkflowRunListener,
-        workflow_run_event_listener: RunEventListenerClient,
-        worker: WorkerContext,
-        namespace: str = "",
-    ):
-        self.action = action
-        self.dispatcher_client = dispatcher_client
-        self.admin_client = admin_client
-        self.event_client = event_client
-        self.rest_client = rest_client
-        self.workflow_listener = workflow_listener
-        self.workflow_run_event_listener = workflow_run_event_listener
-        self.namespace = namespace
-        self.spawn_index = -1
-        self.worker = worker
-
-    @tenacity_retry
-    async 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()
-        # if (
-        #     options is not None
-        #     and "sticky" in options
-        #     and options["sticky"] == True
-        #     and not self.worker.has_workflow(workflow_name)
-        # ):
-        #     raise Exception(
-        #         f"cannot run with sticky: workflow {workflow_name} is not registered on the worker"
-        #     )
-
-        trigger_options = self._prepare_workflow_options(key, options, worker_id)
-
-        return await self.admin_client.aio.run_workflow(
-            workflow_name, input, trigger_options
-        )
-
-    @tenacity_retry
-    async 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 await self.admin_client.aio.run_workflows(bulk_trigger_workflow_runs)
-
-
-class Context(BaseContext):
-    spawn_index = -1
-
-    worker: WorkerContext
-
-    def __init__(
-        self,
-        action: Action,
-        dispatcher_client: DispatcherClient,
-        admin_client: AdminClient,
-        event_client: EventClient,
-        rest_client: RestApi,
-        workflow_listener: PooledWorkflowRunListener,
+        workflow_listener: PooledWorkflowRunListener | None,
+        durable_event_listener: DurableEventListener | None,
         workflow_run_event_listener: RunEventListenerClient,
         worker: WorkerContext,
         namespace: str = "",
@@ -181,44 +64,18 @@ class Context(BaseContext):
         self.worker = worker
         self.validator_registry = validator_registry
 
-        self.aio = ContextAioImpl(
-            action,
-            dispatcher_client,
-            admin_client,
-            event_client,
-            rest_client,
-            workflow_listener,
-            workflow_run_event_listener,
-            worker,
-            namespace,
-        )
-
-        # Check the type of action.action_payload before attempting to load it as JSON
-        if isinstance(action.action_payload, (str, bytes, bytearray)):
-            try:
-                self.data = cast(dict[str, Any], json.loads(action.action_payload))
-            except Exception as e:
-                logger.error(f"Error parsing action payload: {e}")
-                # Assign an empty dictionary if parsing fails
-                self.data: dict[str, Any] = {}  # type: ignore[no-redef]
-        else:
-            # Directly assign the payload to self.data if it's already a dict
-            self.data = (
-                action.action_payload if isinstance(action.action_payload, dict) else {}
-            )
+        self.data = action.action_payload
 
         self.action = action
 
-        # FIXME: stepRunId is a legacy field, we should remove it
-        self.stepRunId = action.step_run_id
-
-        self.step_run_id = action.step_run_id
+        self.step_run_id: str = action.step_run_id
         self.exit_flag = False
         self.dispatcher_client = dispatcher_client
         self.admin_client = admin_client
         self.event_client = event_client
         self.rest_client = rest_client
         self.workflow_listener = workflow_listener
+        self.durable_event_listener = durable_event_listener
         self.workflow_run_event_listener = workflow_run_event_listener
         self.namespace = namespace
 
@@ -227,45 +84,55 @@ class Context(BaseContext):
         self.logger_thread_pool = ThreadPoolExecutor(max_workers=1)
         self.stream_event_thread_pool = ThreadPoolExecutor(max_workers=1)
 
-        # store each key in the overrides field in a lookup table
-        # overrides_data is a dictionary of key-value pairs
-        self.overrides_data = self.data.get("overrides", {})
+        self.input = self.data.input
+
+    def was_skipped(self, task: "Task[TWorkflowInput, R]") -> bool:
+        return self.data.parents.get(task.name, {}).get("skipped", False)
+
+    @property
+    def trigger_data(self) -> JSONSerializableMapping:
+        return self.data.triggers
+
+    def task_output(self, task: "Task[TWorkflowInput, R]") -> "R":
+        from hatchet_sdk.runnables.types import R
 
-        if action.get_group_key_run_id != "":
-            self.input = self.data
-        else:
-            self.input = self.data.get("input", {})
+        if self.was_skipped(task):
+            raise ValueError("{task.name} was skipped")
+
+        action_prefix = self.action.action_id.split(":")[0]
 
-    def step_output(self, step: str) -> dict[str, Any] | BaseModel:
         workflow_validator = next(
-            (v for k, v in self.validator_registry.items() if k.split(":")[-1] == step),
+            (
+                v
+                for k, v in self.validator_registry.items()
+                if k == f"{action_prefix}:{task.name}"
+            ),
             None,
         )
 
         try:
-            parent_step_data = cast(dict[str, Any], self.data["parents"][step])
+            parent_step_data = cast(R, self.data.parents[task.name])
         except KeyError:
-            raise ValueError(f"Step output for '{step}' not found")
+            raise ValueError(f"Step output for '{task.name}' not found")
 
-        if workflow_validator and (v := workflow_validator.step_output):
-            return v.model_validate(parent_step_data)
+        if (
+            parent_step_data
+            and workflow_validator
+            and (v := workflow_validator.step_output)
+        ):
+            return cast(R, v.model_validate(parent_step_data))
 
         return parent_step_data
 
-    def triggered_by_event(self) -> bool:
-        return cast(str, self.data.get("triggered_by", "")) == "event"
-
-    def workflow_input(self) -> dict[str, Any] | T:
-        if (r := self.validator_registry.get(self.action.action_id)) and (
-            i := r.workflow_input
-        ):
-            return cast(
-                T,
-                i.model_validate(self.input),
-            )
+    @property
+    def was_triggered_by_event(self) -> bool:
+        return self.data.triggered_by == "event"
 
+    @property
+    def workflow_input(self) -> JSONSerializableMapping:
         return self.input
 
+    @property
     def workflow_run_id(self) -> str:
         return self.action.workflow_run_id
 
@@ -277,39 +144,18 @@ class Context(BaseContext):
     def done(self) -> bool:
         return self.exit_flag
 
-    def playground(self, name: str, default: str | None = None) -> str | None:
-        # if the key exists in the overrides_data field, return the value
-        if name in self.overrides_data:
-            warn(
-                "Use of `overrides_data` is deprecated.",
-                DeprecationWarning,
-                stacklevel=1,
-            )
-            return str(self.overrides_data[name])
-
-        caller_file = get_caller_file_path()
-
-        self.dispatcher_client.put_overrides_data(
-            OverridesData(
-                stepRunId=self.stepRunId,
-                path=name,
-                value=json.dumps(default),
-                callerFilename=caller_file,
-            )
-        )
-
-        return default
-
     def _log(self, line: str) -> tuple[bool, Exception | None]:
         try:
-            self.event_client.log(message=line, step_run_id=self.stepRunId)
+            self.event_client.log(message=line, step_run_id=self.step_run_id)
             return True, None
         except Exception as e:
             # we don't want to raise an exception here, as it will kill the log thread
             return False, e
 
-    def log(self, line: Any, raise_on_error: bool = False) -> None:
-        if self.stepRunId == "":
+    def log(
+        self, line: str | JSONSerializableMapping, raise_on_error: bool = False
+    ) -> None:
+        if self.step_run_id == "":
             return
 
         if not isinstance(line, str):
@@ -339,45 +185,54 @@ class Context(BaseContext):
         future.add_done_callback(handle_result)
 
     def release_slot(self) -> None:
-        return self.dispatcher_client.release_slot(self.stepRunId)
+        return self.dispatcher_client.release_slot(self.step_run_id)
 
     def _put_stream(self, data: str | bytes) -> None:
         try:
-            self.event_client.stream(data=data, step_run_id=self.stepRunId)
+            self.event_client.stream(data=data, step_run_id=self.step_run_id)
         except Exception as e:
             logger.error(f"Error putting stream event: {e}")
 
     def put_stream(self, data: str | bytes) -> None:
-        if self.stepRunId == "":
+        if self.step_run_id == "":
             return
 
         self.stream_event_thread_pool.submit(self._put_stream, data)
 
-    def refresh_timeout(self, increment_by: str) -> None:
+    def refresh_timeout(self, increment_by: str | timedelta) -> None:
+        if isinstance(increment_by, timedelta):
+            increment_by = timedelta_to_expr(increment_by)
+
         try:
             return self.dispatcher_client.refresh_timeout(
-                step_run_id=self.stepRunId, increment_by=increment_by
+                step_run_id=self.step_run_id, increment_by=increment_by
             )
         except Exception as e:
             logger.error(f"Error refreshing timeout: {e}")
 
+    @property
     def retry_count(self) -> int:
         return self.action.retry_count
 
-    def additional_metadata(self) -> dict[str, Any] | None:
+    @property
+    def additional_metadata(self) -> JSONSerializableMapping | None:
         return self.action.additional_metadata
 
+    @property
     def child_index(self) -> int | None:
         return self.action.child_workflow_index
 
+    @property
     def child_key(self) -> str | None:
         return self.action.child_workflow_key
 
+    @property
     def parent_workflow_run_id(self) -> str | None:
         return self.action.parent_workflow_run_id
 
-    def step_run_errors(self) -> dict[str, str]:
-        errors = cast(dict[str, str], self.data.get("step_run_errors", {}))
+    @property
+    def task_run_errors(self) -> dict[str, str]:
+        errors = self.data.step_run_errors
 
         if not errors:
             logger.error(
@@ -386,61 +241,44 @@ class Context(BaseContext):
 
         return errors
 
-    def fetch_run_failures(self) -> list[dict[str, StrictStr]]:
-        data = self.rest_client.workflow_run_get(self.action.workflow_run_id)
-        other_job_runs = [
-            run for run in (data.job_runs or []) if run.job_id != self.action.job_id
-        ]
-        # TODO: Parse Step Runs using a Pydantic Model rather than a hand crafted dictionary
-        return [
-            {
-                "step_id": step_run.step_id,
-                "step_run_action_name": step_run.step.action,
-                "error": step_run.error,
-            }
-            for job_run in other_job_runs
-            if job_run.step_runs
-            for step_run in job_run.step_runs
-            if step_run.error and step_run.step
-        ]
-
-    @tenacity_retry
-    def spawn_workflow(
+    def fetch_task_run_error(
         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)
+        task: "Task[TWorkflowInput, R]",
+    ) -> str | None:
+        errors = self.data.step_run_errors
 
-        return self.admin_client.run_workflow(workflow_name, input, trigger_options)
+        return errors.get(task.name)
 
-    @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")
+class DurableContext(Context):
+    async def aio_wait_for(
+        self, signal_key: str, *conditions: SleepCondition | UserEventCondition
+    ) -> dict[str, Any]:
+        if self.durable_event_listener is None:
+            raise ValueError("Durable event listener is not available")
 
-        worker_id = self.worker.id()
+        task_id = self.step_run_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"]
+        request = RegisterDurableEventRequest(
+            task_id=task_id,
+            signal_key=signal_key,
+            conditions=list(conditions),
+        )
 
-            key = child_workflow_run.get("key")
-            options = child_workflow_run.get("options", {})
+        self.durable_event_listener.register_durable_event(request)
 
-            trigger_options = self._prepare_workflow_options(key, options, worker_id)
+        return await self.durable_event_listener.result(
+            task_id,
+            signal_key,
+        )
 
-            bulk_trigger_workflow_runs.append(
-                WorkflowRunDict(
-                    workflow_name=workflow_name, input=input, options=trigger_options
-                )
-            )
+    async def aio_sleep_for(self, duration: Duration) -> dict[str, Any]:
+        """
+        Lightweight wrapper for durable sleep. Allows for shorthand usage of `ctx.aio_wait_for` when specifying a sleep condition.
 
-        return self.admin_client.run_workflows(bulk_trigger_workflow_runs)
+        For more complicated conditions, use `ctx.aio_wait_for` directly.
+        """
+
+        return await self.aio_wait_for(
+            f"sleep:{timedelta_to_expr(duration)}", SleepCondition(duration=duration)
+        )

hatchet_sdk/contracts/dispatcher_pb2_grpc.py

@@ -3,7 +3,7 @@
 import grpc
 import warnings
 
-from . import dispatcher_pb2 as dispatcher__pb2
+from hatchet_sdk.contracts import dispatcher_pb2 as dispatcher__pb2
 
 GRPC_GENERATED_VERSION = '1.64.1'
 GRPC_VERSION = grpc.__version__

hatchet_sdk/contracts/events_pb2.py

@@ -15,14 +15,14 @@ _sym_db = _symbol_database.Default()
 from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0c\x65vents.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xb4\x01\n\x05\x45vent\x12\x10\n\x08tenantId\x18\x01 \x01(\t\x12\x0f\n\x07\x65ventId\x18\x02 \x01(\t\x12\x0b\n\x03key\x18\x03 \x01(\t\x12\x0f\n\x07payload\x18\x04 \x01(\t\x12\x32\n\x0e\x65ventTimestamp\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x1f\n\x12\x61\x64\x64itionalMetadata\x18\x06 \x01(\tH\x00\x88\x01\x01\x42\x15\n\x13_additionalMetadata\" \n\x06\x45vents\x12\x16\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x06.Event\"\x92\x01\n\rPutLogRequest\x12\x11\n\tstepRunId\x18\x01 \x01(\t\x12-\n\tcreatedAt\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07message\x18\x03 \x01(\t\x12\x12\n\x05level\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x10\n\x08metadata\x18\x05 \x01(\tB\x08\n\x06_level\"\x10\n\x0ePutLogResponse\"|\n\x15PutStreamEventRequest\x12\x11\n\tstepRunId\x18\x01 \x01(\t\x12-\n\tcreatedAt\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07message\x18\x03 \x01(\x0c\x12\x10\n\x08metadata\x18\x05 \x01(\t\"\x18\n\x16PutStreamEventResponse\"9\n\x14\x42ulkPushEventRequest\x12!\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x11.PushEventRequest\"\x9c\x01\n\x10PushEventRequest\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x0f\n\x07payload\x18\x02 \x01(\t\x12\x32\n\x0e\x65ventTimestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x1f\n\x12\x61\x64\x64itionalMetadata\x18\x04 \x01(\tH\x00\x88\x01\x01\x42\x15\n\x13_additionalMetadata\"%\n\x12ReplayEventRequest\x12\x0f\n\x07\x65ventId\x18\x01 \x01(\t2\x88\x02\n\rEventsService\x12#\n\x04Push\x12\x11.PushEventRequest\x1a\x06.Event\"\x00\x12,\n\x08\x42ulkPush\x12\x15.BulkPushEventRequest\x1a\x07.Events\"\x00\x12\x32\n\x11ReplaySingleEvent\x12\x13.ReplayEventRequest\x1a\x06.Event\"\x00\x12+\n\x06PutLog\x12\x0e.PutLogRequest\x1a\x0f.PutLogResponse\"\x00\x12\x43\n\x0ePutStreamEvent\x12\x16.PutStreamEventRequest\x1a\x17.PutStreamEventResponse\"\x00\x42GZEgithub.com/hatchet-dev/hatchet/internal/services/dispatcher/contractsb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0c\x65vents.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xb4\x01\n\x05\x45vent\x12\x10\n\x08tenantId\x18\x01 \x01(\t\x12\x0f\n\x07\x65ventId\x18\x02 \x01(\t\x12\x0b\n\x03key\x18\x03 \x01(\t\x12\x0f\n\x07payload\x18\x04 \x01(\t\x12\x32\n\x0e\x65ventTimestamp\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x1f\n\x12\x61\x64\x64itionalMetadata\x18\x06 \x01(\tH\x00\x88\x01\x01\x42\x15\n\x13_additionalMetadata\" \n\x06\x45vents\x12\x16\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x06.Event\"\x92\x01\n\rPutLogRequest\x12\x11\n\tstepRunId\x18\x01 \x01(\t\x12-\n\tcreatedAt\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07message\x18\x03 \x01(\t\x12\x12\n\x05level\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x10\n\x08metadata\x18\x05 \x01(\tB\x08\n\x06_level\"\x10\n\x0ePutLogResponse\"|\n\x15PutStreamEventRequest\x12\x11\n\tstepRunId\x18\x01 \x01(\t\x12-\n\tcreatedAt\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07message\x18\x03 \x01(\x0c\x12\x10\n\x08metadata\x18\x05 \x01(\t\"\x18\n\x16PutStreamEventResponse\"9\n\x14\x42ulkPushEventRequest\x12!\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x11.PushEventRequest\"\x9c\x01\n\x10PushEventRequest\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x0f\n\x07payload\x18\x02 \x01(\t\x12\x32\n\x0e\x65ventTimestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x1f\n\x12\x61\x64\x64itionalMetadata\x18\x04 \x01(\tH\x00\x88\x01\x01\x42\x15\n\x13_additionalMetadata\"%\n\x12ReplayEventRequest\x12\x0f\n\x07\x65ventId\x18\x01 \x01(\t2\x88\x02\n\rEventsService\x12#\n\x04Push\x12\x11.PushEventRequest\x1a\x06.Event\"\x00\x12,\n\x08\x42ulkPush\x12\x15.BulkPushEventRequest\x1a\x07.Events\"\x00\x12\x32\n\x11ReplaySingleEvent\x12\x13.ReplayEventRequest\x1a\x06.Event\"\x00\x12+\n\x06PutLog\x12\x0e.PutLogRequest\x1a\x0f.PutLogResponse\"\x00\x12\x43\n\x0ePutStreamEvent\x12\x16.PutStreamEventRequest\x1a\x17.PutStreamEventResponse\"\x00\x42\x45ZCgithub.com/hatchet-dev/hatchet/internal/services/ingestor/contractsb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'events_pb2', _globals)
 if not _descriptor._USE_C_DESCRIPTORS:
   _globals['DESCRIPTOR']._loaded_options = None
-  _globals['DESCRIPTOR']._serialized_options = b'ZEgithub.com/hatchet-dev/hatchet/internal/services/dispatcher/contracts'
+  _globals['DESCRIPTOR']._serialized_options = b'ZCgithub.com/hatchet-dev/hatchet/internal/services/ingestor/contracts'
   _globals['_EVENT']._serialized_start=50
   _globals['_EVENT']._serialized_end=230
   _globals['_EVENTS']._serialized_start=232

hatchet_sdk/contracts/events_pb2_grpc.py

@@ -3,7 +3,7 @@
 import grpc
 import warnings
 
-from . import events_pb2 as events__pb2
+from hatchet_sdk.contracts import events_pb2 as events__pb2
 
 GRPC_GENERATED_VERSION = '1.64.1'
 GRPC_VERSION = grpc.__version__