hatchet-sdk 0.40.0a9__py3-none-any.whl → 0.42.0__py3-none-any.whl

hatchet_sdk/features/scheduled.py

@@ -0,0 +1,248 @@
+import datetime
+from typing import Any, Coroutine, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from hatchet_sdk.client import Client
+from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
+from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
+    CronWorkflowsOrderByField,
+)
+from hatchet_sdk.clients.rest.models.scheduled_workflows import ScheduledWorkflows
+from hatchet_sdk.clients.rest.models.scheduled_workflows_list import (
+    ScheduledWorkflowsList,
+)
+from hatchet_sdk.clients.rest.models.workflow_run_order_by_direction import (
+    WorkflowRunOrderByDirection,
+)
+
+
+class CreateScheduledTriggerInput(BaseModel):
+    """
+    Schema for creating a scheduled workflow run.
+
+    Attributes:
+        input (Dict[str, Any]): The input data for the scheduled workflow.
+        additional_metadata (Dict[str, str]): Additional metadata associated with the future run (e.g. ["key1:value1", "key2:value2"]).
+        trigger_at (Optional[datetime.datetime]): The datetime when the run should be triggered.
+    """
+
+    input: Dict[str, Any] = {}
+    additional_metadata: Dict[str, str] = {}
+    trigger_at: Optional[datetime.datetime] = None
+
+
+class ScheduledClient:
+    """
+    Client for managing scheduled workflows synchronously.
+
+    Attributes:
+        _client (Client): The underlying client used to interact with the REST API.
+        aio (ScheduledClientAsync): Asynchronous counterpart of ScheduledClient.
+    """
+
+    _client: Client
+
+    def __init__(self, _client: Client) -> None:
+        """
+        Initializes the ScheduledClient with a given Client instance.
+
+        Args:
+            _client (Client): The client instance to be used for REST interactions.
+        """
+        self._client = _client
+        self.aio: "ScheduledClientAsync" = ScheduledClientAsync(_client)
+
+    def create(
+        self,
+        workflow_name: str,
+        trigger_at: datetime.datetime,
+        input: Dict[str, Any],
+        additional_metadata: Dict[str, str],
+    ) -> ScheduledWorkflows:
+        """
+        Creates a new scheduled workflow run asynchronously.
+
+        Args:
+            workflow_name (str): The name of the scheduled workflow.
+            trigger_at (datetime.datetime): The datetime when the run should be triggered.
+            input (Dict[str, Any]): The input data for the scheduled workflow.
+            additional_metadata (Dict[str, str]): Additional metadata associated with the future run as a key-value pair (e.g. {"key1": "value1", "key2": "value2"}).
+
+        Returns:
+            ScheduledWorkflows: The created scheduled workflow instance.
+        """
+
+        validated_input = CreateScheduledTriggerInput(
+            trigger_at=trigger_at, input=input, additional_metadata=additional_metadata
+        )
+
+        return self._client.rest.schedule_create(
+            workflow_name,
+            validated_input.trigger_at,
+            validated_input.input,
+            validated_input.additional_metadata,
+        )
+
+    def delete(self, scheduled: Union[str, ScheduledWorkflows]) -> None:
+        """
+        Deletes a scheduled workflow run.
+
+        Args:
+            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to delete.
+        """
+        id_ = scheduled
+        if isinstance(scheduled, ScheduledWorkflows):
+            id_ = scheduled.metadata.id
+        self._client.rest.schedule_delete(id_)
+
+    def list(
+        self,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        workflow_id: Optional[str] = None,
+        additional_metadata: Optional[List[str]] = None,
+        order_by_field: Optional[CronWorkflowsOrderByField] = None,
+        order_by_direction: Optional[WorkflowRunOrderByDirection] = None,
+    ) -> ScheduledWorkflowsList:
+        """
+        Retrieves a list of scheduled workflows based on provided filters.
+
+        Args:
+            offset (Optional[int]): The starting point for the list.
+            limit (Optional[int]): The maximum number of items to return.
+            workflow_id (Optional[str]): Filter by specific workflow ID.
+            additional_metadata (Optional[List[str]]): Filter by additional metadata keys (e.g. ["key1:value1", "key2:value2"]).
+            order_by_field (Optional[CronWorkflowsOrderByField]): Field to order the results by.
+            order_by_direction (Optional[WorkflowRunOrderByDirection]): Direction to order the results.
+
+        Returns:
+            List[ScheduledWorkflows]: A list of scheduled workflows matching the criteria.
+        """
+        return self._client.rest.schedule_list(
+            offset=offset,
+            limit=limit,
+            workflow_id=workflow_id,
+            additional_metadata=additional_metadata,
+            order_by_field=order_by_field,
+            order_by_direction=order_by_direction,
+        )
+
+    def get(self, scheduled: Union[str, ScheduledWorkflows]) -> ScheduledWorkflows:
+        """
+        Retrieves a specific scheduled workflow by scheduled run trigger ID.
+
+        Args:
+            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to retrieve.
+
+        Returns:
+            ScheduledWorkflows: The requested scheduled workflow instance.
+        """
+        id_ = scheduled
+        if isinstance(scheduled, ScheduledWorkflows):
+            id_ = scheduled.metadata.id
+        return self._client.rest.schedule_get(id_)
+
+
+class ScheduledClientAsync:
+    """
+    Asynchronous client for managing scheduled workflows.
+
+    Attributes:
+        _client (Client): The underlying client used to interact with the REST API asynchronously.
+    """
+
+    _client: Client
+
+    def __init__(self, _client: Client) -> None:
+        """
+        Initializes the ScheduledClientAsync with a given Client instance.
+
+        Args:
+            _client (Client): The client instance to be used for asynchronous REST interactions.
+        """
+        self._client = _client
+
+    async def create(
+        self,
+        workflow_name: str,
+        trigger_at: datetime.datetime,
+        input: Dict[str, Any],
+        additional_metadata: Dict[str, str],
+    ) -> ScheduledWorkflows:
+        """
+        Creates a new scheduled workflow run asynchronously.
+
+        Args:
+            workflow_name (str): The name of the scheduled workflow.
+            trigger_at (datetime.datetime): The datetime when the run should be triggered.
+            input (Dict[str, Any]): The input data for the scheduled workflow.
+            additional_metadata (Dict[str, str]): Additional metadata associated with the future run.
+
+        Returns:
+            ScheduledWorkflows: The created scheduled workflow instance.
+        """
+        return await self._client.rest.aio.schedule_create(
+            workflow_name, trigger_at, input, additional_metadata
+        )
+
+    async def delete(self, scheduled: Union[str, ScheduledWorkflows]) -> None:
+        """
+        Deletes a scheduled workflow asynchronously.
+
+        Args:
+            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to delete.
+        """
+        id_ = scheduled
+        if isinstance(scheduled, ScheduledWorkflows):
+            id_ = scheduled.metadata.id
+        await self._client.rest.aio.schedule_delete(id_)
+
+    async def list(
+        self,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        workflow_id: Optional[str] = None,
+        additional_metadata: Optional[List[str]] = None,
+        order_by_field: Optional[CronWorkflowsOrderByField] = None,
+        order_by_direction: Optional[WorkflowRunOrderByDirection] = None,
+    ) -> ScheduledWorkflowsList:
+        """
+        Retrieves a list of scheduled workflows based on provided filters asynchronously.
+
+        Args:
+            offset (Optional[int]): The starting point for the list.
+            limit (Optional[int]): The maximum number of items to return.
+            workflow_id (Optional[str]): Filter by specific workflow ID.
+            additional_metadata (Optional[List[str]]): Filter by additional metadata keys (e.g. ["key1:value1", "key2:value2"]).
+            order_by_field (Optional[CronWorkflowsOrderByField]): Field to order the results by.
+            order_by_direction (Optional[WorkflowRunOrderByDirection]): Direction to order the results.
+
+        Returns:
+            ScheduledWorkflowsList: A list of scheduled workflows matching the criteria.
+        """
+        return await self._client.rest.aio.schedule_list(
+            offset=offset,
+            limit=limit,
+            workflow_id=workflow_id,
+            additional_metadata=additional_metadata,
+            order_by_field=order_by_field,
+            order_by_direction=order_by_direction,
+        )
+
+    async def get(
+        self, scheduled: Union[str, ScheduledWorkflows]
+    ) -> ScheduledWorkflows:
+        """
+        Retrieves a specific scheduled workflow by scheduled run trigger ID asynchronously.
+
+        Args:
+            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to retrieve.
+
+        Returns:
+            ScheduledWorkflows: The requested scheduled workflow instance.
+        """
+        id_ = scheduled
+        if isinstance(scheduled, ScheduledWorkflows):
+            id_ = scheduled.metadata.id
+        return await self._client.rest.aio.schedule_get(id_)

hatchet_sdk/hatchet.py

@@ -1,31 +1,43 @@
 import asyncio
 import logging
-from typing import List, Optional
+from typing import Any, Callable, Optional, ParamSpec, TypeVar
 
 from typing_extensions import deprecated
 
 from hatchet_sdk.clients.rest_client import RestApi
-from hatchet_sdk.compute.configs import Compute
-from hatchet_sdk.contracts.workflows_pb2 import (
+
+## TODO: These type stubs need to be updated to mass MyPy, and then we can remove this ignore
+## There are file-level type ignore lines in the corresponding .pyi files.
+from hatchet_sdk.contracts.workflows_pb2 import (  # type: ignore[attr-defined]
     ConcurrencyLimitStrategy,
     CreateStepRateLimit,
     DesiredWorkerLabels,
     StickyStrategy,
 )
+from hatchet_sdk.features.cron import CronClient
+from hatchet_sdk.features.scheduled import ScheduledClient
 from hatchet_sdk.labels import DesiredWorkerLabel
 from hatchet_sdk.loader import ClientConfig, ConfigLoader
 from hatchet_sdk.rate_limit import RateLimit
 
 from .client import Client, new_client, new_client_raw
+from .clients.admin import AdminClient
+from .clients.dispatcher.dispatcher import DispatcherClient
+from .clients.events import EventClient
+from .clients.run_event_listener import RunEventListenerClient
 from .logger import logger
-from .worker import Worker
+from .worker.worker import Worker
 from .workflow import ConcurrencyExpression, WorkflowMeta
 
+P = ParamSpec("P")
+R = TypeVar("R")
+
 
-def workflow(
+## TODO: Fix return type here to properly type hint the metaclass
+def workflow(  # type: ignore[no-untyped-def]
     name: str = "",
-    on_events: list | None = None,
-    on_crons: list | None = None,
+    on_events: list[str] | None = None,
+    on_crons: list[str] | None = None,
     version: str = "",
     timeout: str = "60m",
     schedule_timeout: str = "5m",
@@ -33,27 +45,10 @@ def workflow(
     default_priority: int | None = None,
     concurrency: ConcurrencyExpression | None = None,
 ):
-    """
-    Decorator to mark a class as a workflow.
-
-    Args:
-        name (str, optional): The name of the workflow. Defaults to an empty string.
-        on_events (list, optional): A list of events that trigger the workflow. Defaults to None.
-        on_crons (list, optional): A list of cron expressions that trigger the workflow. Defaults to None.
-        version (str, optional): The version of the workflow. Defaults to an empty string.
-        timeout (str, optional): The timeout for the workflow. Defaults to "60m".
-        schedule_timeout (str, optional): The schedule timeout for the workflow. Defaults to "5m".
-        sticky (StickyStrategy, optional): The sticky strategy for the workflow. Defaults to None.
-        default_priority (int, optional): The default priority for the workflow. Defaults to None.
-        concurrency (ConcurrencyExpression, optional): The concurrency expression for the workflow. Defaults to None.
-
-    Returns:
-        function: The decorated class with workflow metadata.
-    """
     on_events = on_events or []
     on_crons = on_crons or []
 
-    def inner(cls) -> WorkflowMeta:
+    def inner(cls: Any) -> WorkflowMeta:
         cls.on_events = on_events
         cls.on_crons = on_crons
         cls.name = name or str(cls.__name__)
@@ -65,7 +60,9 @@ def workflow(
         cls.concurrency_expression = concurrency
         # Define a new class with the same name and bases as the original, but
         # with WorkflowMeta as its metaclass
-        return WorkflowMeta(cls.name, cls.__bases__, dict(cls.__dict__))
+
+        ## TODO: Figure out how to type this metaclass correctly
+        return WorkflowMeta(cls.name, cls.__bases__, dict(cls.__dict__))  # type: ignore[no-untyped-call]
 
     return inner
 
@@ -73,30 +70,16 @@ def workflow(
 def step(
     name: str = "",
     timeout: str = "",
-    parents: List[str] | None = None,
+    parents: list[str] | None = None,
     retries: int = 0,
-    rate_limits: List[RateLimit] | None = None,
-    desired_worker_labels: dict[str:DesiredWorkerLabel] = {},
-    compute: Compute | None = None,
-):
-    """
-    Decorator to mark a function as a step in a workflow.
-
-    Args:
-        name (str, optional): The name of the step. Defaults to the function name.
-        timeout (str, optional): The timeout for the step. Defaults to an empty string.
-        parents (List[str], optional): A list of parent step names. Defaults to an empty list.
-        retries (int, optional): The number of retries for the step. Defaults to 0.
-        rate_limits (List[RateLimit], optional): A list of rate limits for the step. Defaults to None.
-        desired_worker_labels (dict[str:DesiredWorkerLabel], optional): A dictionary of desired worker labels. Defaults to an empty dictionary.
-        compute (Compute, optional): The compute configuration for the step. Hatchet Cloud only. Defaults to None.
-
-    Returns:
-        function: The decorated function with step metadata.
-    """
+    rate_limits: list[RateLimit] | None = None,
+    desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+    backoff_factor: float | None = None,
+    backoff_max_seconds: int | None = None,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
     parents = parents or []
 
-    def inner(func):
+    def inner(func: Callable[P, R]) -> Callable[P, R]:
         limits = None
         if rate_limits:
             limits = [
@@ -104,18 +87,20 @@ def step(
                 for rate_limit in rate_limits or []
             ]
 
-        func._step_name = name.lower() or str(func.__name__).lower()
-        func._step_parents = parents
-        func._step_timeout = timeout
-        func._step_retries = retries
-        func._step_rate_limits = limits
-        func._step_compute = compute
+        ## TODO: Use Protocol here to help with MyPy errors
+        func._step_name = name.lower() or str(func.__name__).lower()  # type: ignore[attr-defined]
+        func._step_parents = parents  # type: ignore[attr-defined]
+        func._step_timeout = timeout  # type: ignore[attr-defined]
+        func._step_retries = retries  # type: ignore[attr-defined]
+        func._step_rate_limits = limits  # type: ignore[attr-defined]
+        func._step_backoff_factor = backoff_factor  # type: ignore[attr-defined]
+        func._step_backoff_max_seconds = backoff_max_seconds  # type: ignore[attr-defined]
 
-        func._step_desired_worker_labels = {}
+        func._step_desired_worker_labels = {}  # type: ignore[attr-defined]
 
         for key, d in desired_worker_labels.items():
             value = d["value"] if "value" in d else None
-            func._step_desired_worker_labels[key] = DesiredWorkerLabels(
+            func._step_desired_worker_labels[key] = DesiredWorkerLabels(  # type: ignore[attr-defined]
                 strValue=str(value) if not isinstance(value, int) else None,
                 intValue=value if isinstance(value, int) else None,
                 required=d["required"] if "required" in d else None,
@@ -132,9 +117,11 @@ def on_failure_step(
     name: str = "",
     timeout: str = "",
     retries: int = 0,
-    rate_limits: List[RateLimit] | None = None,
-):
-    def inner(func):
+    rate_limits: list[RateLimit] | None = None,
+    backoff_factor: float | None = None,
+    backoff_max_seconds: int | None = None,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def inner(func: Callable[P, R]) -> Callable[P, R]:
         limits = None
         if rate_limits:
             limits = [
@@ -142,10 +129,14 @@ def on_failure_step(
                 for rate_limit in rate_limits or []
             ]
 
-        func._on_failure_step_name = name.lower() or str(func.__name__).lower()
-        func._on_failure_step_timeout = timeout
-        func._on_failure_step_retries = retries
-        func._on_failure_step_rate_limits = limits
+        ## TODO: Use Protocol here to help with MyPy errors
+        func._on_failure_step_name = name.lower() or str(func.__name__).lower()  # type: ignore[attr-defined]
+        func._on_failure_step_timeout = timeout  # type: ignore[attr-defined]
+        func._on_failure_step_retries = retries  # type: ignore[attr-defined]
+        func._on_failure_step_rate_limits = limits  # type: ignore[attr-defined]
+        func._on_failure_step_backoff_factor = backoff_factor  # type: ignore[attr-defined]
+        func._on_failure_step_backoff_max_seconds = backoff_max_seconds  # type: ignore[attr-defined]
+
         return func
 
     return inner
@@ -155,11 +146,12 @@ def concurrency(
     name: str = "",
     max_runs: int = 1,
     limit_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
-):
-    def inner(func):
-        func._concurrency_fn_name = name.lower() or str(func.__name__).lower()
-        func._concurrency_max_runs = max_runs
-        func._concurrency_limit_strategy = limit_strategy
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def inner(func: Callable[P, R]) -> Callable[P, R]:
+        ## TODO: Use Protocol here to help with MyPy errors
+        func._concurrency_fn_name = name.lower() or str(func.__name__).lower()  # type: ignore[attr-defined]
+        func._concurrency_max_runs = max_runs  # type: ignore[attr-defined]
+        func._concurrency_limit_strategy = limit_strategy  # type: ignore[attr-defined]
 
         return func
 
@@ -180,8 +172,8 @@ class HatchetRest:
     rest: RestApi
 
     def __init__(self, config: ClientConfig = ClientConfig()):
-        config: ClientConfig = ConfigLoader(".").load_client_config(config)
-        self.rest = RestApi(config.server_url, config.token, config.tenant_id)
+        _config: ClientConfig = ConfigLoader(".").load_client_config(config)
+        self.rest = RestApi(_config.server_url, _config.token, _config.tenant_id)
 
 
 class Hatchet:
@@ -192,6 +184,8 @@ class Hatchet:
     for working with Hatchet workers, workflows, and steps.
 
     Attributes:
+        cron (CronClient): Interface for cron trigger operations.
+
         admin (AdminClient): Interface for administrative operations.
         dispatcher (DispatcherClient): Interface for dispatching operations.
         event (EventClient): Interface for event-related operations.
@@ -199,13 +193,17 @@ class Hatchet:
     """
 
     _client: Client
+    cron: CronClient
+    scheduled: ScheduledClient
 
     @classmethod
-    def from_environment(cls, defaults: ClientConfig = ClientConfig(), **kwargs):
+    def from_environment(
+        cls, defaults: ClientConfig = ClientConfig(), **kwargs: Any
+    ) -> "Hatchet":
         return cls(client=new_client(defaults), **kwargs)
 
     @classmethod
-    def from_config(cls, config: ClientConfig, **kwargs):
+    def from_config(cls, config: ClientConfig, **kwargs: Any) -> "Hatchet":
         return cls(client=new_client_raw(config), **kwargs)
 
     def __init__(
@@ -230,6 +228,9 @@ class Hatchet:
         if debug:
             logger.setLevel(logging.DEBUG)
 
+        self.cron = CronClient(self._client)
+        self.scheduled = ScheduledClient(self._client)
+
     @property
     @deprecated(
         "Direct access to client is deprecated and will be removed in a future version. Use specific client properties (Hatchet.admin, Hatchet.dispatcher, Hatchet.event, Hatchet.rest) instead. [0.32.0]",
@@ -238,31 +239,31 @@ class Hatchet:
         return self._client
 
     @property
-    def admin(self):
+    def admin(self) -> AdminClient:
         return self._client.admin
 
     @property
-    def dispatcher(self):
+    def dispatcher(self) -> DispatcherClient:
         return self._client.dispatcher
 
     @property
-    def event(self):
+    def event(self) -> EventClient:
         return self._client.event
 
     @property
-    def rest(self):
+    def rest(self) -> RestApi:
         return self._client.rest
 
     @property
-    def listener(self):
+    def listener(self) -> RunEventListenerClient:
         return self._client.listener
 
     @property
-    def config(self):
+    def config(self) -> ClientConfig:
         return self._client.config
 
     @property
-    def tenant_id(self):
+    def tenant_id(self) -> str:
         return self._client.config.tenant_id
 
     concurrency = staticmethod(concurrency)
@@ -275,7 +276,7 @@ class Hatchet:
 
     def worker(
         self, name: str, max_runs: int | None = None, labels: dict[str, str | int] = {}
-    ):
+    ) -> Worker:
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:

hatchet_sdk/loader.py

@@ -1,3 +1,4 @@
+import json
 import os
 from logging import Logger, getLogger
 from typing import Dict, Optional
@@ -38,9 +39,10 @@ class ClientConfig:
         logger: Logger = None,
         grpc_max_recv_message_length: int = 4 * 1024 * 1024,  # 4MB
         grpc_max_send_message_length: int = 4 * 1024 * 1024,  # 4MB
-        runnable_actions: list[
-            str
-        ] = None,  # list of action names that are runnable, defaults to all actions
+        otel_exporter_oltp_endpoint: str | None = None,
+        otel_service_name: str | None = None,
+        otel_exporter_oltp_headers: dict[str, str] | None = None,
+        otel_exporter_oltp_protocol: str | None = None,
     ):
         self.tenant_id = tenant_id
         self.tls_config = tls_config
@@ -51,6 +53,10 @@ class ClientConfig:
         self.logInterceptor = logger
         self.grpc_max_recv_message_length = grpc_max_recv_message_length
         self.grpc_max_send_message_length = grpc_max_send_message_length
+        self.otel_exporter_oltp_endpoint = otel_exporter_oltp_endpoint
+        self.otel_service_name = otel_service_name
+        self.otel_exporter_oltp_headers = otel_exporter_oltp_headers
+        self.otel_exporter_oltp_protocol = otel_exporter_oltp_protocol
 
         if not self.logInterceptor:
             self.logInterceptor = getLogger()
@@ -65,12 +71,6 @@ class ClientConfig:
 
         self.listener_v2_timeout = listener_v2_timeout
 
-        self.runnable_actions: list[str] | None = (
-            [self.namespace + action for action in runnable_actions]
-            if runnable_actions
-            else None
-        )
-
 
 class ConfigLoader:
     def __init__(self, directory: str):
@@ -136,11 +136,31 @@ class ConfigLoader:
 
         tls_config = self._load_tls_config(config_data["tls"], host_port)
 
-        raw_runnable_actions = get_config_value(
-            "runnable_actions", "HATCHET_CLOUD_ACTIONS"
+        otel_exporter_oltp_endpoint = get_config_value(
+            "otel_exporter_oltp_endpoint", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_ENDPOINT"
+        )
+
+        otel_service_name = get_config_value(
+            "otel_service_name", "HATCHET_CLIENT_OTEL_SERVICE_NAME"
         )
-        runnable_actions = (
-            raw_runnable_actions.split(",") if raw_runnable_actions else None
+
+        _oltp_headers = get_config_value(
+            "otel_exporter_oltp_headers", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_HEADERS"
+        )
+
+        if _oltp_headers:
+            try:
+                otel_header_key, api_key = _oltp_headers.split("=", maxsplit=1)
+                otel_exporter_oltp_headers = {otel_header_key: api_key}
+            except ValueError:
+                raise ValueError(
+                    "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_HEADERS must be in the format `key=value`"
+                )
+        else:
+            otel_exporter_oltp_headers = None
+
+        otel_exporter_oltp_protocol = get_config_value(
+            "otel_exporter_oltp_protocol", "HATCHET_CLIENT_OTEL_EXPORTER_OTLP_PROTOCOL"
         )
 
         return ClientConfig(
@@ -154,7 +174,10 @@ class ConfigLoader:
             logger=defaults.logInterceptor,
             grpc_max_recv_message_length=grpc_max_recv_message_length,
             grpc_max_send_message_length=grpc_max_send_message_length,
-            runnable_actions=runnable_actions,
+            otel_exporter_oltp_endpoint=otel_exporter_oltp_endpoint,
+            otel_service_name=otel_service_name,
+            otel_exporter_oltp_headers=otel_exporter_oltp_headers,
+            otel_exporter_oltp_protocol=otel_exporter_oltp_protocol,
         )
 
     def _load_tls_config(self, tls_data: Dict, host_port) -> ClientTLSConfig:

hatchet_sdk/utils/serialization.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+
+def flatten(xs: dict[str, Any], parent_key: str, separator: str) -> dict[str, Any]:
+    items = []
+
+    for k, v in xs.items():
+        new_key = parent_key + separator + k if parent_key else k
+
+        if isinstance(v, dict):
+            items.extend(flatten(v, new_key, separator).items())
+        else:
+            items.append((new_key, v))
+
+    return dict(items)