hatchet-sdk 1.6.2__py3-none-any.whl → 1.6.3__py3-none-any.whl

hatchet_sdk/runnables/workflow.py

@@ -195,6 +195,15 @@ class BaseWorkflow(Generic[TWorkflowInput]):
         key: str | None = None,
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunTriggerConfig:
+        """
+        Create a bulk run item for the workflow. This is intended to be used in conjunction with the various `run_many` methods.
+
+        :param input: The input data for the workflow.
+        :param key: The key for the workflow run. This is used to identify the run in the bulk operation and for deduplication.
+        :param options: Additional options for the workflow run.
+
+        :returns: A `WorkflowRunTriggerConfig` object that can be used to trigger the workflow run, which you then pass into the `run_many` methods.
+        """
         return WorkflowRunTriggerConfig(
             workflow_name=self.config.name,
             input=self._serialize_input(input),
@@ -216,8 +225,39 @@ class BaseWorkflow(Generic[TWorkflowInput]):
 
 class Workflow(BaseWorkflow[TWorkflowInput]):
     """
-    A Hatchet workflow, which allows you to define tasks to be run and perform actions on the workflow, such as
-    running / spawning children and scheduling future runs.
+    A Hatchet workflow, which allows you to define tasks to be run and perform actions on the workflow.
+
+    Workflows in Hatchet represent coordinated units of work that can be triggered, scheduled, or run on a cron schedule.
+    Each workflow can contain multiple tasks that can be arranged in dependencies (DAGs), have customized retry behavior,
+    timeouts, concurrency controls, and more.
+
+    Example:
+    ```python
+    from pydantic import BaseModel
+    from hatchet_sdk import Hatchet
+
+    class MyInput(BaseModel):
+        name: str
+
+    hatchet = Hatchet()
+    workflow = hatchet.workflow("my-workflow", input_type=MyInput)
+
+    @workflow.task()
+    def greet(input, ctx):
+        return f"Hello, {input.name}!"
+
+    # Run the workflow
+    result = workflow.run(MyInput(name="World"))
+    ```
+
+    Workflows support various execution patterns including:
+    - One-time execution with `run()` or `aio_run()`
+    - Scheduled execution with `schedule()`
+    - Cron-based recurring execution with `create_cron()`
+    - Bulk operations with `run_many()`
+
+    Tasks within workflows can be defined with `@workflow.task()` or `@workflow.durable_task()` decorators
+    and can be arranged into complex dependency patterns.
     """
 
     def run_no_wait(
@@ -225,6 +265,15 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
+        """
+        Synchronously trigger a workflow run without waiting for it to complete.
+        This method is useful for starting a workflow run and immediately returning a reference to the run without blocking while the workflow runs.
+
+        :param input: The input data for the workflow.
+        :param options: Additional options for workflow execution.
+
+        :returns: A `WorkflowRunRef` object representing the reference to the workflow run.
+        """
         return self.client._client.admin.run_workflow(
             workflow_name=self.config.name,
             input=self._serialize_input(input),
@@ -236,6 +285,17 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> dict[str, Any]:
+        """
+        Run the workflow synchronously and wait for it to complete.
+
+        This method triggers a workflow run, blocks until completion, and returns the final result.
+
+        :param input: The input data for the workflow, must match the workflow's input type.
+        :param options: Additional options for workflow execution like metadata and parent workflow ID.
+
+        :returns: The result of the workflow execution as a dictionary.
+        """
+
         ref = self.client._client.admin.run_workflow(
             workflow_name=self.config.name,
             input=self._serialize_input(input),
@@ -249,6 +309,16 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
+        """
+        Asynchronously trigger a workflow run without waiting for it to complete.
+        This method is useful for starting a workflow run and immediately returning a reference to the run without blocking while the workflow runs.
+
+        :param input: The input data for the workflow.
+        :param options: Additional options for workflow execution.
+
+        :returns: A `WorkflowRunRef` object representing the reference to the workflow run.
+        """
+
         return await self.client._client.admin.aio_run_workflow(
             workflow_name=self.config.name,
             input=self._serialize_input(input),
@@ -260,6 +330,16 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> dict[str, Any]:
+        """
+        Run the workflow asynchronously and wait for it to complete.
+
+        This method triggers a workflow run, blocks until completion, and returns the final result.
+
+        :param input: The input data for the workflow, must match the workflow's input type.
+        :param options: Additional options for workflow execution like metadata and parent workflow ID.
+
+        :returns: The result of the workflow execution as a dictionary.
+        """
         ref = await self.client._client.admin.aio_run_workflow(
             workflow_name=self.config.name,
             input=self._serialize_input(input),
@@ -272,6 +352,13 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[dict[str, Any]]:
+        """
+        Run a workflow in bulk and wait for all runs to complete.
+        This method triggers multiple workflow runs, blocks until all of them complete, and returns the final results.
+
+        :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :returns: A list of results for each workflow run.
+        """
         refs = self.client._client.admin.run_workflows(
             workflows=workflows,
         )
@@ -282,6 +369,13 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[dict[str, Any]]:
+        """
+        Run a workflow in bulk and wait for all runs to complete.
+        This method triggers multiple workflow runs, blocks until all of them complete, and returns the final results.
+
+        :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :returns: A list of results for each workflow run.
+        """
         refs = await self.client._client.admin.aio_run_workflows(
             workflows=workflows,
         )
@@ -292,6 +386,14 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[WorkflowRunRef]:
+        """
+        Run a workflow in bulk without waiting for all runs to complete.
+
+        This method triggers multiple workflow runs and immediately returns a list of references to the runs without blocking while the workflows run.
+
+        :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :returns: A list of `WorkflowRunRef` objects, each representing a reference to a workflow run.
+        """
         return self.client._client.admin.run_workflows(
             workflows=workflows,
         )
@@ -300,6 +402,15 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         self,
         workflows: list[WorkflowRunTriggerConfig],
     ) -> list[WorkflowRunRef]:
+        """
+        Run a workflow in bulk without waiting for all runs to complete.
+
+        This method triggers multiple workflow runs and immediately returns a list of references to the runs without blocking while the workflows run.
+
+        :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+
+        :returns: A list of `WorkflowRunRef` objects, each representing a reference to a workflow run.
+        """
         return await self.client._client.admin.aio_run_workflows(
             workflows=workflows,
         )
@@ -310,6 +421,14 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
+        """
+        Schedule a workflow to run at a specific time.
+
+        :param run_at: The time at which to schedule the workflow.
+        :param input: The input data for the workflow.
+        :param options: Additional options for workflow execution.
+        :returns: A `WorkflowVersion` object representing the scheduled workflow.
+        """
         return self.client._client.admin.schedule_workflow(
             name=self.config.name,
             schedules=cast(list[datetime | timestamp_pb2.Timestamp], [run_at]),
@@ -323,6 +442,14 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
     ) -> WorkflowVersion:
+        """
+        Schedule a workflow to run at a specific time.
+
+        :param run_at: The time at which to schedule the workflow.
+        :param input: The input data for the workflow.
+        :param options: Additional options for workflow execution.
+        :returns: A `WorkflowVersion` object representing the scheduled workflow.
+        """
         return await self.client._client.admin.aio_schedule_workflow(
             name=self.config.name,
             schedules=cast(list[datetime | timestamp_pb2.Timestamp], [run_at]),
@@ -338,6 +465,17 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         additional_metadata: JSONSerializableMapping = {},
         priority: int | None = None,
     ) -> CronWorkflows:
+        """
+        Create a cron job for the workflow.
+
+        :param cron_name: The name of the cron job.
+        :param expression: The cron expression that defines the schedule for the cron job.
+        :param input: The input data for the workflow.
+        :param additional_metadata: Additional metadata for the cron job.
+        :param priority: The priority of the cron job. Must be between 1 and 3, inclusive.
+
+        :returns: A `CronWorkflows` object representing the created cron job.
+        """
         return self.client.cron.create(
             workflow_name=self.config.name,
             cron_name=cron_name,
@@ -355,6 +493,17 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         additional_metadata: JSONSerializableMapping = {},
         priority: int | None = None,
     ) -> CronWorkflows:
+        """
+        Create a cron job for the workflow.
+
+        :param cron_name: The name of the cron job.
+        :param expression: The cron expression that defines the schedule for the cron job.
+        :param input: The input data for the workflow.
+        :param additional_metadata: Additional metadata for the cron job.
+        :param priority: The priority of the cron job. Must be between 1 and 3, inclusive.
+
+        :returns: A `CronWorkflows` object representing the created cron job.
+        """
         return await self.client.cron.aio_create(
             workflow_name=self.config.name,
             cron_name=cron_name,
@@ -393,46 +542,35 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         cancel_if: list[Condition | OrGroup] = [],
     ) -> Callable[[Callable[[TWorkflowInput, Context], R]], Task[TWorkflowInput, R]]:
         """
-        A decorator to transform a function into a Hatchet task that run as part of a workflow.
+        A decorator to transform a function into a Hatchet task that runs as part of a workflow.
 
         :param name: The name of the task. If not specified, defaults to the name of the function being wrapped by the `task` decorator.
-        :type name: str | None
 
-        :param timeout: The execution timeout of the task. Defaults to 60 minutes.
-        :type timeout: datetime.timedelta | str
+        :param schedule_timeout: The maximum time to wait for the task to be scheduled. The run will be canceled if the task does not begin within this time.
+
+        :param execution_timeout: The maximum time to wait for the task to complete. The run will be canceled if the task does not complete within this time.
 
-        :param parents: A list of tasks that are parents of the task. Note: Parents must be defined before their children. Defaults to an empty list (no parents).
-        :type parents: list[Task]
+        :param parents: A list of tasks that are parents of the task. Note: Parents must be defined before their children.
 
-        :param retries: The number of times to retry the task before failing. Default: `0`
-        :type retries: int
+        :param retries: The number of times to retry the task before failing.
 
-        :param rate_limits: A list of rate limit configurations for the task. Defaults to an empty list (no rate limits).
-        :type rate_limits: list[RateLimit]
+        :param rate_limits: A list of rate limit configurations for the task.
 
-        :param desired_worker_labels: A dictionary of desired worker labels that determine to which worker the task should be assigned. See documentation and examples on affinity and worker labels for more details. Defaults to an empty dictionary (no desired worker labels).
-        :type desired_worker_labels: dict[str, DesiredWorkerLabel]
+        :param desired_worker_labels: A dictionary of desired worker labels that determine to which worker the task should be assigned. See documentation and examples on affinity and worker labels for more details.
 
-        :param backoff_factor: The backoff factor for controlling exponential backoff in retries. Default: `None`
-        :type backoff_factor: float | None
+        :param backoff_factor: The backoff factor for controlling exponential backoff in retries.
 
-        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue. Default: `None`
-        :type backoff_max_seconds: int | None
+        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
 
-        :param concurrency: A list of concurrency expressions for the task. Defaults to an empty list (no concurrency).
-        :type concurrency: list[ConcurrencyExpression]
+        :param concurrency: A list of concurrency expressions for the task.
 
-        :param wait_for: A list of conditions that must be met before the task can run. Defaults to an empty list (no conditions).
-        :type wait_for: list[Condition | OrGroup]
+        :param wait_for: A list of conditions that must be met before the task can run.
 
-        :param skip_if: A list of conditions that, if met, will cause the task to be skipped. Defaults to an empty list (no conditions).
-        :type skip_if: list[Condition | OrGroup]
+        :param skip_if: A list of conditions that, if met, will cause the task to be skipped.
 
-        :param cancel_if: A list of conditions that, if met, will cause the task to be canceled. Defaults to an empty list (no conditions).
-        :type cancel_if: list[Condition | OrGroup]
+        :param cancel_if: A list of conditions that, if met, will cause the task to be canceled.
 
         :returns: A decorator which creates a `Task` object.
-        :rtype: Callable[[Callable[[Type[BaseModel], Context], R]], Task[Type[BaseModel], R]]
         """
 
         def inner(
@@ -493,43 +631,32 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         See the Hatchet docs for more information on durable execution to decide if this is right for you.
 
         :param name: The name of the task. If not specified, defaults to the name of the function being wrapped by the `task` decorator.
-        :type name: str | None
 
-        :param timeout: The execution timeout of the task. Defaults to 60 minutes.
-        :type timeout: datetime.timedelta | str
+        :param schedule_timeout: The maximum time to wait for the task to be scheduled. The run will be canceled if the task does not begin within this time.
 
-        :param parents: A list of tasks that are parents of the task. Note: Parents must be defined before their children. Defaults to an empty list (no parents).
-        :type parents: list[Task]
+        :param execution_timeout: The maximum time to wait for the task to complete. The run will be canceled if the task does not complete within this time.
 
-        :param retries: The number of times to retry the task before failing. Default: `0`
-        :type retries: int
+        :param parents: A list of tasks that are parents of the task. Note: Parents must be defined before their children.
 
-        :param rate_limits: A list of rate limit configurations for the task. Defaults to an empty list (no rate limits).
-        :type rate_limits: list[RateLimit]
+        :param retries: The number of times to retry the task before failing.
 
-        :param desired_worker_labels: A dictionary of desired worker labels that determine to which worker the task should be assigned. See documentation and examples on affinity and worker labels for more details. Defaults to an empty dictionary (no desired worker labels).
-        :type desired_worker_labels: dict[str, DesiredWorkerLabel]
+        :param rate_limits: A list of rate limit configurations for the task.
 
-        :param backoff_factor: The backoff factor for controlling exponential backoff in retries. Default: `None`
-        :type backoff_factor: float | None
+        :param desired_worker_labels: A dictionary of desired worker labels that determine to which worker the task should be assigned. See documentation and examples on affinity and worker labels for more details.
 
-        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue. Default: `None`
-        :type backoff_max_seconds: int | None
+        :param backoff_factor: The backoff factor for controlling exponential backoff in retries.
 
-        :param concurrency: A list of concurrency expressions for the task. Defaults to an empty list (no concurrency).
-        :type concurrency: list[ConcurrencyExpression]
+        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
 
-        :param wait_for: A list of conditions that must be met before the task can run. Defaults to an empty list (no conditions).
-        :type wait_for: list[Condition | OrGroup]
+        :param concurrency: A list of concurrency expressions for the task.
 
-        :param skip_if: A list of conditions that, if met, will cause the task to be skipped. Defaults to an empty list (no conditions).
-        :type skip_if: list[Condition | OrGroup]
+        :param wait_for: A list of conditions that must be met before the task can run.
 
-        :param cancel_if: A list of conditions that, if met, will cause the task to be canceled. Defaults to an empty list (no conditions).
-        :type cancel_if: list[Condition | OrGroup]
+        :param skip_if: A list of conditions that, if met, will cause the task to be skipped.
+
+        :param cancel_if: A list of conditions that, if met, will cause the task to be canceled.
 
         :returns: A decorator which creates a `Task` object.
-        :rtype: Callable[[Callable[[Type[BaseModel], Context], R]], Task[Type[BaseModel], R]]
         """
 
         def inner(
@@ -579,25 +706,22 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         A decorator to transform a function into a Hatchet on-failure task that runs as the last step in a workflow that had at least one task fail.
 
         :param name: The name of the on-failure task. If not specified, defaults to the name of the function being wrapped by the `on_failure_task` decorator.
-        :type name: str | None
 
-        :param timeout: The execution timeout of the on-failure task. Defaults to 60 minutes.
-        :type timeout: datetime.timedelta | str
+        :param schedule_timeout: The maximum time to wait for the task to be scheduled. The run will be canceled if the task does not begin within this time.
+
+        :param execution_timeout: The maximum time to wait for the task to complete. The run will be canceled if the task does not complete within this time.
 
-        :param retries: The number of times to retry the on-failure task before failing. Default: `0`
-        :type retries: int
+        :param retries: The number of times to retry the on-failure task before failing.
 
-        :param rate_limits: A list of rate limit configurations for the on-failure task. Defaults to an empty list (no rate limits).
-        :type rate_limits: list[RateLimit]
+        :param rate_limits: A list of rate limit configurations for the on-failure task.
 
-        :param backoff_factor: The backoff factor for controlling exponential backoff in retries. Default: `None`
-        :type backoff_factor: float | None
+        :param backoff_factor: The backoff factor for controlling exponential backoff in retries.
 
-        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue. Default: `None`
-        :type backoff_max_seconds: int | None
+        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
+
+        :param concurrency: A list of concurrency expressions for the on-success task.
 
         :returns: A decorator which creates a `Task` object.
-        :rtype: Callable[[Callable[[Type[BaseModel], Context], R]], Task[Type[BaseModel], R]]
         """
 
         def inner(
@@ -642,25 +766,22 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         A decorator to transform a function into a Hatchet on-success task that runs as the last step in a workflow that had all upstream tasks succeed.
 
         :param name: The name of the on-success task. If not specified, defaults to the name of the function being wrapped by the `on_failure_task` decorator.
-        :type name: str | None
 
-        :param timeout: The execution timeout of the on-success task. Defaults to 60 minutes.
-        :type timeout: datetime.timedelta | str
+        :param schedule_timeout: The maximum time to wait for the task to be scheduled. The run will be canceled if the task does not begin within this time.
 
-        :param retries: The number of times to retry the on-success task before failing. Default: `0`
-        :type retries: int
+        :param execution_timeout: The maximum time to wait for the task to complete. The run will be canceled if the task does not complete within this time.
 
-        :param rate_limits: A list of rate limit configurations for the on-success task. Defaults to an empty list (no rate limits).
-        :type rate_limits: list[RateLimit]
+        :param retries: The number of times to retry the on-success task before failing
 
-        :param backoff_factor: The backoff factor for controlling exponential backoff in retries. Default: `None`
-        :type backoff_factor: float | None
+        :param rate_limits: A list of rate limit configurations for the on-success task.
 
-        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue. Default: `None`
-        :type backoff_max_seconds: int | None
+        :param backoff_factor: The backoff factor for controlling exponential backoff in retries.
 
-        :returns: A decorator which creates a `Task` object.
-        :rtype: Callable[[Callable[[Type[BaseModel], Context], R]], Task[Type[BaseModel], R]]
+        :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
+
+        :param concurrency: A list of concurrency expressions for the on-success task.
+
+        :returns: A decorator which creates a Task object.
         """
 
         def inner(

hatchet_sdk/v0/features/cron.py

@@ -20,7 +20,7 @@ class CreateCronTriggerInput(BaseModel):
     Attributes:
         expression (str): The cron expression defining the schedule.
         input (dict): The input data for the cron workflow.
-        additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger (e.g. {"key1": "value1", "key2": "value2"}).
+        additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger.
     """
 
     expression: str = None
@@ -97,7 +97,7 @@ class CronClient:
             cron_name (str): The name of the cron trigger.
             expression (str): The cron expression defining the schedule.
             input (dict): The input data for the cron workflow.
-            additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger (e.g. {"key1": "value1", "key2": "value2"}).
+            additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger.
 
         Returns:
             CronWorkflows: The created cron workflow instance.
@@ -209,7 +209,7 @@ class CronClientAsync:
             cron_name (str): The name of the cron trigger.
             expression (str): The cron expression defining the schedule.
             input (dict): The input data for the cron workflow.
-            additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger (e.g. {"key1": "value1", "key2": "value2"}).
+            additional_metadata (dict[str, str]): Additional metadata associated with the cron trigger.
 
         Returns:
             CronWorkflows: The created cron workflow instance.

hatchet_sdk/v0/features/scheduled.py

@@ -67,7 +67,7 @@ class ScheduledClient:
             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"}).
+            additional_metadata (Dict[str, str]): Additional metadata associated with the future run as a key-value pair.
 
         Returns:
             ScheduledWorkflows: The created scheduled workflow instance.

hatchet_sdk/v0/hatchet.py

@@ -234,9 +234,9 @@ class Hatchet:
         Initialize a new Hatchet instance.
 
         Args:
-            debug (bool, optional): Enable debug logging. Defaults to False.
-            client (Optional[Client], optional): A pre-configured Client instance. Defaults to None.
-            config (ClientConfig, optional): Configuration for creating a new Client. Defaults to ClientConfig().
+            debug (bool, optional): Enable debug logging.
+            client (Optional[Client], optional): A pre-configured Client instance.
+            config (ClientConfig, optional): Configuration for creating a new Client.
         """
         if client is not None:
             self._client = client

hatchet_sdk/v0/opentelemetry/instrumentor.py

@@ -57,7 +57,6 @@ def create_traceparent() -> str | None:
     :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:
     """
 
     carrier: dict[str, str] = {}
@@ -75,10 +74,9 @@ def parse_carrier_from_metadata(metadata: dict[str, str] | None) -> Context | No
 
     :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:
 
@@ -108,13 +106,12 @@ def inject_traceparent_into_metadata(
     `OTEL_TRACEPARENT_KEY`. If no `traceparent` is provided, it attempts to create one.
 
     :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:
 

hatchet_sdk/worker/worker.py

@@ -11,7 +11,7 @@ from enum import Enum
 from multiprocessing import Queue
 from multiprocessing.process import BaseProcess
 from types import FrameType
-from typing import Any, AsyncGenerator, Callable, TypeVar
+from typing import Any, AsyncGenerator, Callable, TypeVar, Union
 from warnings import warn
 
 from aiohttp import web
@@ -60,7 +60,7 @@ class HealthCheckResponse(BaseModel):
     name: str
     slots: int
     actions: list[str]
-    labels: dict[str, str | int]
+    labels: dict[str, Union[str, int]]
     python_version: str
 
 
@@ -88,7 +88,7 @@ class Worker:
         config: ClientConfig,
         slots: int,
         durable_slots: int,
-        labels: dict[str, str | int] = {},
+        labels: dict[str, Union[str, int]] = {},
         debug: bool = False,
         owned_loop: bool = True,
         handle_kill: bool = True,

{hatchet_sdk-1.6.2.dist-info → hatchet_sdk-1.6.3.dist-info}/METADATA

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