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

hatchet_sdk/hatchet.py

@@ -1,6 +1,6 @@
 import asyncio
 import logging
-from typing import Any, Callable, Type, cast, overload
+from typing import Any, Callable, Type, Union, cast, overload
 
 from hatchet_sdk import Context, DurableContext
 from hatchet_sdk.client import Client
@@ -41,15 +41,7 @@ class Hatchet:
     Main client for interacting with the Hatchet SDK.
 
     This class provides access to various client interfaces and utility methods
-    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.
-        rest (RestApi): Interface for REST API operations.
+    for working with Hatchet workers, workflows, tasks, and our various feature clients.
     """
 
     def __init__(
@@ -58,19 +50,6 @@ class Hatchet:
         client: Client | None = None,
         config: ClientConfig | None = None,
     ):
-        """
-        Initialize a new Hatchet instance.
-
-        :param debug: Enable debug logging. Default: `False`
-        :type debug: bool
-
-        :param client: A pre-configured `Client` instance. Default: `None`.
-        :type client: Client | None
-
-        :param config: Configuration for creating a new Client. Defaults to ClientConfig()
-        :type config: ClientConfig
-        """
-
         if debug:
             logger.setLevel(logging.DEBUG)
 
@@ -80,34 +59,60 @@ class Hatchet:
 
     @property
     def cron(self) -> CronClient:
+        """
+        The cron client is a client for managing cron workflows within Hatchet.
+        """
         return self._client.cron
 
     @property
     def logs(self) -> LogsClient:
+        """
+        The logs client is a client for interacting with Hatchet's logs API.
+        """
         return self._client.logs
 
     @property
     def metrics(self) -> MetricsClient:
+        """
+        The metrics client is a client for reading metrics out of Hatchet's metrics API.
+        """
         return self._client.metrics
 
     @property
     def rate_limits(self) -> RateLimitsClient:
+        """
+        The rate limits client is a wrapper for Hatchet's gRPC API that makes it easier to work with rate limits in Hatchet.
+        """
         return self._client.rate_limits
 
     @property
     def runs(self) -> RunsClient:
+        """
+        The runs client is a client for interacting with task and workflow runs within Hatchet.
+        """
         return self._client.runs
 
     @property
     def scheduled(self) -> ScheduledClient:
+        """
+        The scheduled client is a client for managing scheduled workflows within Hatchet.
+        """
         return self._client.scheduled
 
     @property
     def workers(self) -> WorkersClient:
+        """
+        The workers client is a client for managing workers programmatically within Hatchet.
+        """
         return self._client.workers
 
     @property
     def workflows(self) -> WorkflowsClient:
+        """
+        The workflows client is a client for managing workflows programmatically within Hatchet.
+
+        Note that workflows are the declaration, _not_ the individual runs. If you're looking for runs, use the `RunsClient` instead.
+        """
         return self._client.workflows
 
     @property
@@ -116,6 +121,9 @@ class Hatchet:
 
     @property
     def event(self) -> EventClient:
+        """
+        The event client, which you can use to push events to Hatchet.
+        """
         return self._client.event
 
     @property
@@ -128,14 +136,24 @@ class Hatchet:
 
     @property
     def tenant_id(self) -> str:
+        """
+        The tenant id you're operating in.
+        """
         return self._client.config.tenant_id
 
+    @property
+    def namespace(self) -> str:
+        """
+        The current namespace you're interacting with.
+        """
+        return self._client.config.namespace
+
     def worker(
         self,
         name: str,
         slots: int = 100,
         durable_slots: int = 1_000,
-        labels: dict[str, str | int] = {},
+        labels: dict[str, Union[str, int]] = {},
         workflows: list[BaseWorkflow[Any]] = [],
         lifespan: LifespanFn | None = None,
     ) -> Worker:
@@ -143,20 +161,18 @@ class Hatchet:
         Create a Hatchet worker on which to run workflows.
 
         :param name: The name of the worker.
-        :type name: str
 
-        :param slots: The number of workflow slots on the worker. In other words, the number of concurrent tasks the worker can run at any point in time. Default: 100
-        :type slots: int
+        :param slots: The number of workflow slots on the worker. In other words, the number of concurrent tasks the worker can run at any point in time
+
+        :param durable_slots: The number of durable workflow slots on the worker. In other words, the number of concurrent tasks the worker can run at any point in time that are durable.
 
-        :param labels: A dictionary of labels to assign to the worker. For more details, view examples on affinity and worker labels. Defaults to an empty dictionary (no labels)
-        :type labels: dict[str, str | int]
+        :param labels: A dictionary of labels to assign to the worker. For more details, view examples on affinity and worker labels.
 
-        :param workflows: A list of workflows to register on the worker, as a shorthand for calling `register_workflow` on each or `register_workflows` on all of them. Defaults to an empty list
-        :type workflows: list[Workflow]
+        :param workflows: A list of workflows to register on the worker, as a shorthand for calling `register_workflow` on each or `register_workflows` on all of them.
 
+        :param lifespan: A lifespan function to run on the worker. This function will be called when the worker is started, and can be used to perform any setup or teardown tasks.
 
         :returns: The created `Worker` object, which exposes an instance method `start` which can be called to start the worker.
-        :rtype: Worker
         """
 
         try:
@@ -226,37 +242,26 @@ class Hatchet:
         Define a Hatchet workflow, which can then declare `task`s and be `run`, `schedule`d, and so on.
 
         :param name: The name of the workflow.
-        :type name: str
 
-        :param description: A description for the workflow. Default: None
-        :type description: str | None
-
-        :param version: A version for the workflow. Default: None
-        :type version: str | None
+        :param description: A description for the workflow
 
         :param input_validator: A Pydantic model to use as a validator for the `input` to the tasks in the workflow. If no validator is provided, defaults to an `EmptyModel` under the hood. The `EmptyModel` is a Pydantic model with no fields specified, and with the `extra` config option set to `"allow"`.
-        :type input_validator: Type[BaseModel]
 
-        :param on_events: A list of event triggers for the workflow - events which cause the workflow to be run. Defaults to an empty list, meaning the workflow will not be run on any event pushes.
-        :type on_events: list[str]
+        :param on_events: A list of event triggers for the workflow - events which cause the workflow to be run.
+
+        :param on_crons: A list of cron triggers for the workflow.
 
-        :param on_crons: A list of cron triggers for the workflow. Defaults to an empty list, meaning the workflow will not be run on any cron schedules.
-        :type on_crons: list[str]
+        :param version: A version for the workflow
 
-        :param sticky: A sticky strategy for the workflow. Default: `None`
-        :type sticky: StickyStategy
+        :param sticky: A sticky strategy for the workflow
 
-        :param default_priority: The priority of the workflow. Higher values will cause this workflow to have priority in scheduling over other, lower priority ones. Default: `1`
-        :type default_priority: int
+        :param default_priority: The priority of the workflow. Higher values will cause this workflow to have priority in scheduling over other, lower priority ones.
 
         :param concurrency: A concurrency object controlling the concurrency settings for this workflow.
-        :type concurrency: ConcurrencyExpression | None
 
         :param task_defaults: A `TaskDefaults` object controlling the default task settings for this workflow.
-        :type task_defaults: TaskDefaults
 
         :returns: The created `Workflow` object, which can be used to declare tasks, run the workflow, and so on.
-        :rtype: Workflow
         """
 
         return Workflow[TWorkflowInput](
@@ -351,55 +356,38 @@ class Hatchet:
         A decorator to transform a function into a standalone 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
 
-        :param description: An optional description for the task. Default: None
-        :type description: str | None
+        :param description: An optional description for the task.
 
         :param input_validator: A Pydantic model to use as a validator for the input to the task. If no validator is provided, defaults to an `EmptyModel`.
-        :type input_validator: Type[BaseModel]
 
-        :param on_events: A list of event triggers for the task - events which cause the task to be run. Defaults to an empty list.
-        :type on_events: list[str]
+        :param on_events: A list of event triggers for the task - events which cause the task to be run.
 
-        :param on_crons: A list of cron triggers for the task. Defaults to an empty list.
-        :type on_crons: list[str]
+        :param on_crons: A list of cron triggers for the task.
 
-        :param version: A version for the task. Default: None
-        :type version: str | None
+        :param version: A version for the task.
 
-        :param sticky: A sticky strategy for the task. Default: None
-        :type sticky: StickyStrategy | None
+        :param sticky: A sticky strategy for the task.
 
-        :param default_priority: The priority of the task. Higher values will cause this task to have priority in scheduling. Default: 1
-        :type default_priority: int
+        :param default_priority: The priority of the task. Higher values will cause this task to have priority in scheduling.
 
         :param concurrency: A concurrency object controlling the concurrency settings for this task.
-        :type concurrency: ConcurrencyExpression | None
 
-        :param schedule_timeout: The maximum time allowed for scheduling the task. Default: DEFAULT_SCHEDULE_TIMEOUT
-        :type schedule_timeout: Duration
+        :param schedule_timeout: The maximum time allowed for scheduling the task.
 
-        :param execution_timeout: The maximum time allowed for executing the task. Default: DEFAULT_EXECUTION_TIMEOUT
-        :type execution_timeout: Duration
+        :param execution_timeout: The maximum time allowed for executing the task.
 
-        :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.
-        :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.
-        :type desired_worker_labels: dict[str, DesiredWorkerLabel]
 
-        :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.
 
         :returns: A decorator which creates a `Standalone` task object.
-        :rtype: Callable[[Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]]
         """
 
         workflow = Workflow[TWorkflowInput](
@@ -411,6 +399,7 @@ class Hatchet:
                 on_crons=on_crons,
                 sticky=sticky,
                 concurrency=concurrency,
+                default_priority=default_priority,
                 input_validator=input_validator
                 or cast(Type[TWorkflowInput], EmptyModel),
             ),
@@ -527,55 +516,38 @@ class Hatchet:
         A decorator to transform a function into a standalone Hatchet _durable_ 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
 
-        :param description: An optional description for the task. Default: None
-        :type description: str | None
+        :param description: An optional description for the task.
 
         :param input_validator: A Pydantic model to use as a validator for the input to the task. If no validator is provided, defaults to an `EmptyModel`.
-        :type input_validator: Type[BaseModel]
 
-        :param on_events: A list of event triggers for the task - events which cause the task to be run. Defaults to an empty list.
-        :type on_events: list[str]
+        :param on_events: A list of event triggers for the task - events which cause the task to be run.
 
-        :param on_crons: A list of cron triggers for the task. Defaults to an empty list.
-        :type on_crons: list[str]
+        :param on_crons: A list of cron triggers for the task.
 
-        :param version: A version for the task. Default: None
-        :type version: str | None
+        :param version: A version for the task.
 
-        :param sticky: A sticky strategy for the task. Default: None
-        :type sticky: StickyStrategy | None
+        :param sticky: A sticky strategy for the task.
 
-        :param default_priority: The priority of the task. Higher values will cause this task to have priority in scheduling. Default: 1
-        :type default_priority: int
+        :param default_priority: The priority of the task. Higher values will cause this task to have priority in scheduling.
 
         :param concurrency: A concurrency object controlling the concurrency settings for this task.
-        :type concurrency: ConcurrencyExpression | None
 
-        :param schedule_timeout: The maximum time allowed for scheduling the task. Default: DEFAULT_SCHEDULE_TIMEOUT
-        :type schedule_timeout: Duration
+        :param schedule_timeout: The maximum time allowed for scheduling the task.
 
-        :param execution_timeout: The maximum time allowed for executing the task. Default: DEFAULT_EXECUTION_TIMEOUT
-        :type execution_timeout: Duration
+        :param execution_timeout: The maximum time allowed for executing the task.
 
-        :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.
-        :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.
-        :type desired_worker_labels: dict[str, DesiredWorkerLabel]
 
-        :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.
 
         :returns: A decorator which creates a `Standalone` task object.
-        :rtype: Callable[[Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]]
         """
 
         workflow = Workflow[TWorkflowInput](
@@ -589,6 +561,7 @@ class Hatchet:
                 concurrency=concurrency,
                 input_validator=input_validator
                 or cast(Type[TWorkflowInput], EmptyModel),
+                default_priority=default_priority,
             ),
             self,
         )

hatchet_sdk/opentelemetry/instrumentor.py

@@ -59,7 +59,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] = {}
@@ -79,10 +78,9 @@ def parse_carrier_from_metadata(
 
     :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:
 
@@ -112,13 +110,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:
 
@@ -141,22 +138,23 @@ def inject_traceparent_into_metadata(
 
 
 class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
+    """
+    Hatchet OpenTelemetry instrumentor.
+
+    The instrumentor provides an OpenTelemetry integration for Hatchet by setting up
+    tracing and metrics collection.
+
+    :param tracer_provider: TracerProvider | None: The OpenTelemetry TracerProvider to use.
+            If not provided, the global tracer provider will be used.
+    :param meter_provider: MeterProvider | None: The OpenTelemetry MeterProvider to use.
+            If not provided, a no-op meter provider will be used.
+    """
+
     def __init__(
         self,
         tracer_provider: TracerProvider | None = None,
         meter_provider: MeterProvider | None = None,
     ):
-        """
-        Hatchet OpenTelemetry instrumentor.
-
-        The instrumentor provides an OpenTelemetry integration for Hatchet by setting up
-        tracing and metrics collection.
-
-        :param tracer_provider: TracerProvider | None: The OpenTelemetry TracerProvider to use.
-                If not provided, the global tracer provider will be used.
-        :param meter_provider: MeterProvider | None: The OpenTelemetry MeterProvider to use.
-                If not provided, a no-op meter provider will be used.
-        """
 
         self.tracer_provider = tracer_provider or get_tracer_provider()
         self.meter_provider = meter_provider or NoOpMeterProvider()
@@ -269,17 +267,17 @@ class HatchetInstrumentor(BaseInstrumentor):  # type: ignore[misc]
     ## IMPORTANT: Keep these types in sync with the wrapped method's signature
     async def _wrap_handle_cancel_action(
         self,
-        wrapped: Callable[[str], Coroutine[None, None, Exception | None]],
+        wrapped: Callable[[Action], Coroutine[None, None, Exception | None]],
         instance: Runner,
-        args: tuple[str],
+        args: tuple[Action],
         kwargs: Any,
     ) -> Exception | None:
-        step_run_id = args[0]
+        action = args[0]
 
         with self._tracer.start_as_current_span(
             "hatchet.cancel_step_run",
             attributes={
-                "hatchet.step_run_id": step_run_id,
+                "hatchet.step_run_id": action.step_run_id,
             },
         ):
             return await wrapped(*args, **kwargs)

hatchet_sdk/runnables/standalone.py

@@ -75,6 +75,15 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> R:
+        """
+        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._extract_result(self._workflow.run(input, options))
 
     async def aio_run(
@@ -82,6 +91,16 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> R:
+        """
+        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.
+        """
         result = await self._workflow.aio_run(input, options)
         return self._extract_result(result)
 
@@ -90,6 +109,16 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> TaskRunRef[TWorkflowInput, R]:
+        """
+        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._workflow.run_no_wait(input, options)
 
         return TaskRunRef[TWorkflowInput, R](self, ref)
@@ -99,17 +128,40 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> TaskRunRef[TWorkflowInput, R]:
+        """
+        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.
+        """
         ref = await self._workflow.aio_run_no_wait(input, options)
 
         return TaskRunRef[TWorkflowInput, R](self, ref)
 
     def run_many(self, workflows: list[WorkflowRunTriggerConfig]) -> list[R]:
+        """
+        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.
+        """
         return [
             self._extract_result(result)
             for result in self._workflow.run_many(workflows)
         ]
 
     async def aio_run_many(self, workflows: list[WorkflowRunTriggerConfig]) -> list[R]:
+        """
+        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.
+        """
         return [
             self._extract_result(result)
             for result in await self._workflow.aio_run_many(workflows)
@@ -118,6 +170,14 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
     def run_many_no_wait(
         self, workflows: list[WorkflowRunTriggerConfig]
     ) -> list[TaskRunRef[TWorkflowInput, R]]:
+        """
+        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.
+        """
         refs = self._workflow.run_many_no_wait(workflows)
 
         return [TaskRunRef[TWorkflowInput, R](self, ref) for ref in refs]
@@ -125,6 +185,15 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
     async def aio_run_many_no_wait(
         self, workflows: list[WorkflowRunTriggerConfig]
     ) -> list[TaskRunRef[TWorkflowInput, R]]:
+        """
+        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.
+        """
         refs = await self._workflow.aio_run_many_no_wait(workflows)
 
         return [TaskRunRef[TWorkflowInput, R](self, ref) for ref in refs]
@@ -135,6 +204,14 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         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._workflow.schedule(
             run_at=run_at,
             input=input,
@@ -147,6 +224,14 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         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._workflow.aio_schedule(
             run_at=run_at,
             input=input,
@@ -159,12 +244,25 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         expression: str,
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         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._workflow.create_cron(
             cron_name=cron_name,
             expression=expression,
             input=input,
             additional_metadata=additional_metadata,
+            priority=priority,
         )
 
     async def aio_create_cron(
@@ -173,12 +271,25 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         expression: str,
         input: TWorkflowInput = cast(TWorkflowInput, EmptyModel()),
         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._workflow.aio_create_cron(
             cron_name=cron_name,
             expression=expression,
             input=input,
             additional_metadata=additional_metadata,
+            priority=priority,
         )
 
     def to_task(self) -> Task[TWorkflowInput, R]: