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

hatchet_sdk/hatchet.py

@@ -1,197 +1,35 @@
 import asyncio
 import logging
-from typing import Any, Callable, Optional, ParamSpec, Type, TypeVar, Union
-
-from pydantic import BaseModel
-from typing_extensions import deprecated
+from typing import Any, Callable, Type, cast, overload
 
+from hatchet_sdk import Context, DurableContext
+from hatchet_sdk.client import Client
+from hatchet_sdk.clients.admin import AdminClient
+from hatchet_sdk.clients.dispatcher.dispatcher import DispatcherClient
+from hatchet_sdk.clients.events import EventClient
 from hatchet_sdk.clients.rest_client import RestApi
-from hatchet_sdk.context.context import Context
-from hatchet_sdk.contracts.workflows_pb2 import (
-    ConcurrencyLimitStrategy,
-    CreateStepRateLimit,
-    DesiredWorkerLabels,
-    StickyStrategy,
-)
+from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
+from hatchet_sdk.config import ClientConfig
 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.logger import logger
 from hatchet_sdk.rate_limit import RateLimit
-from hatchet_sdk.v2.callable import HatchetCallable
-
-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.worker import Worker
-from .workflow import (
+from hatchet_sdk.runnables.standalone import Standalone
+from hatchet_sdk.runnables.types import (
+    DEFAULT_EXECUTION_TIMEOUT,
+    DEFAULT_SCHEDULE_TIMEOUT,
     ConcurrencyExpression,
-    WorkflowInterface,
-    WorkflowMeta,
-    WorkflowStepProtocol,
+    EmptyModel,
+    R,
+    StickyStrategy,
+    TaskDefaults,
+    TWorkflowInput,
+    WorkflowConfig,
 )
-
-T = TypeVar("T", bound=BaseModel)
-R = TypeVar("R")
-P = ParamSpec("P")
-
-TWorkflow = TypeVar("TWorkflow", bound=object)
-
-
-def workflow(
-    name: str = "",
-    on_events: list[str] | None = None,
-    on_crons: list[str] | None = None,
-    version: str = "",
-    timeout: str = "60m",
-    schedule_timeout: str = "5m",
-    sticky: Union[StickyStrategy.Value, None] = None,  # type: ignore[name-defined]
-    default_priority: int | None = None,
-    concurrency: ConcurrencyExpression | None = None,
-    input_validator: Type[T] | None = None,
-) -> Callable[[Type[TWorkflow]], WorkflowMeta]:
-    on_events = on_events or []
-    on_crons = on_crons or []
-
-    def inner(cls: Type[TWorkflow]) -> WorkflowMeta:
-        nonlocal name
-        name = name or str(cls.__name__)
-
-        setattr(cls, "on_events", on_events)
-        setattr(cls, "on_crons", on_crons)
-        setattr(cls, "name", name)
-        setattr(cls, "version", version)
-        setattr(cls, "timeout", timeout)
-        setattr(cls, "schedule_timeout", schedule_timeout)
-        setattr(cls, "sticky", sticky)
-        setattr(cls, "default_priority", default_priority)
-        setattr(cls, "concurrency_expression", concurrency)
-
-        # Define a new class with the same name and bases as the original, but
-        # with WorkflowMeta as its metaclass
-
-        ## TODO: Figure out how to type this metaclass correctly
-        setattr(cls, "input_validator", input_validator)
-
-        return WorkflowMeta(name, cls.__bases__, dict(cls.__dict__))
-
-    return inner
-
-
-def step(
-    name: str = "",
-    timeout: str = "",
-    parents: list[str] | None = None,
-    retries: int = 0,
-    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: Callable[P, R]) -> Callable[P, R]:
-        limits = None
-        if rate_limits:
-            limits = [rate_limit._req for rate_limit in rate_limits or []]
-
-        setattr(func, "_step_name", name.lower() or str(func.__name__).lower())
-        setattr(func, "_step_parents", parents)
-        setattr(func, "_step_timeout", timeout)
-        setattr(func, "_step_retries", retries)
-        setattr(func, "_step_rate_limits", limits)
-        setattr(func, "_step_backoff_factor", backoff_factor)
-        setattr(func, "_step_backoff_max_seconds", backoff_max_seconds)
-
-        def create_label(d: DesiredWorkerLabel) -> DesiredWorkerLabels:
-            value = d["value"] if "value" in d else None
-            return DesiredWorkerLabels(
-                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,  # type: ignore[arg-type]
-                weight=d["weight"] if "weight" in d else None,
-                comparator=d["comparator"] if "comparator" in d else None,  # type: ignore[arg-type]
-            )
-
-        setattr(
-            func,
-            "_step_desired_worker_labels",
-            {key: create_label(d) for key, d in desired_worker_labels.items()},
-        )
-
-        return func
-
-    return inner
-
-
-def on_failure_step(
-    name: str = "",
-    timeout: str = "",
-    retries: int = 0,
-    rate_limits: list[RateLimit] | None = None,
-    backoff_factor: float | None = None,
-    backoff_max_seconds: int | None = None,
-) -> Callable[..., Any]:
-    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
-        limits = None
-        if rate_limits:
-            limits = [
-                CreateStepRateLimit(key=rate_limit.static_key, units=rate_limit.units)  # type: ignore[arg-type]
-                for rate_limit in rate_limits or []
-            ]
-
-        setattr(
-            func, "_on_failure_step_name", name.lower() or str(func.__name__).lower()
-        )
-        setattr(func, "_on_failure_step_timeout", timeout)
-        setattr(func, "_on_failure_step_retries", retries)
-        setattr(func, "_on_failure_step_rate_limits", limits)
-        setattr(func, "_on_failure_step_backoff_factor", backoff_factor)
-        setattr(func, "_on_failure_step_backoff_max_seconds", backoff_max_seconds)
-
-        return func
-
-    return inner
-
-
-def concurrency(
-    name: str = "",
-    max_runs: int = 1,
-    limit_strategy: ConcurrencyLimitStrategy = ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
-) -> Callable[..., Any]:
-    def inner(func: Callable[[Context], Any]) -> Callable[[Context], Any]:
-        setattr(
-            func,
-            "_concurrency_fn_name",
-            name.lower() or str(func.__name__).lower(),
-        )
-        setattr(func, "_concurrency_max_runs", max_runs)
-        setattr(func, "_concurrency_limit_strategy", limit_strategy)
-
-        return func
-
-    return inner
-
-
-class HatchetRest:
-    """
-    Main client for interacting with the Hatchet API.
-
-    This class provides access to various client interfaces and utility methods
-    for working with Hatchet via the REST API,
-
-    Attributes:
-        rest (RestApi): Interface for REST API operations.
-    """
-
-    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)
+from hatchet_sdk.runnables.workflow import BaseWorkflow, Workflow
+from hatchet_sdk.utils.timedelta_to_expression import Duration
+from hatchet_sdk.worker.worker import Worker
 
 
 class Hatchet:
@@ -214,48 +52,32 @@ class Hatchet:
     cron: CronClient
     scheduled: ScheduledClient
 
-    @classmethod
-    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: Any) -> "Hatchet":
-        return cls(client=new_client_raw(config), **kwargs)
-
     def __init__(
         self,
         debug: bool = False,
-        client: Optional[Client] = None,
+        client: Client | None = None,
         config: ClientConfig = ClientConfig(),
     ):
         """
         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().
+        :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 client is not None:
-            self._client = client
-        else:
-            self._client = new_client(config, debug)
 
         if debug:
             logger.setLevel(logging.DEBUG)
 
+        self._client = client if client else Client(config=config, debug=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]",
-    )
-    def client(self) -> Client:
-        return self._client
-
     @property
     def admin(self) -> AdminClient:
         return self._client.admin
@@ -284,17 +106,33 @@ class Hatchet:
     def tenant_id(self) -> str:
         return self._client.config.tenant_id
 
-    concurrency = staticmethod(concurrency)
+    def worker(
+        self,
+        name: str,
+        slots: int = 100,
+        labels: dict[str, str | int] = {},
+        workflows: list[BaseWorkflow[Any]] = [],
+    ) -> Worker:
+        """
+        Create a Hatchet worker on which to run workflows.
 
-    workflow = staticmethod(workflow)
+        :param name: The name of the worker.
+        :type name: str
 
-    step = staticmethod(step)
+        :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
 
-    on_failure_step = staticmethod(on_failure_step)
+        :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 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]
+
+
+        :returns: The created `Worker` object, which exposes an instance method `start` which can be called to start the worker.
+        :rtype: Worker
+        """
 
-    def worker(
-        self, name: str, max_runs: int | None = None, labels: dict[str, str | int] = {}
-    ) -> Worker:
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
@@ -302,9 +140,444 @@ class Hatchet:
 
         return Worker(
             name=name,
-            max_runs=max_runs,
+            slots=slots,
             labels=labels,
             config=self._client.config,
             debug=self._client.debug,
             owned_loop=loop is None,
+            workflows=workflows,
         )
+
+    @overload
+    def workflow(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: None = None,
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        task_defaults: TaskDefaults = TaskDefaults(),
+    ) -> Workflow[EmptyModel]: ...
+
+    @overload
+    def workflow(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: Type[TWorkflowInput],
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        task_defaults: TaskDefaults = TaskDefaults(),
+    ) -> Workflow[TWorkflowInput]: ...
+
+    def workflow(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: Type[TWorkflowInput] | None = None,
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        task_defaults: TaskDefaults = TaskDefaults(),
+    ) -> Workflow[EmptyModel] | Workflow[TWorkflowInput]:
+        """
+        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 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_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 sticky: A sticky strategy for the workflow. Default: `None`
+        :type sticky: StickyStategy
+
+        :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 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](
+            WorkflowConfig(
+                name=name,
+                version=version,
+                description=description,
+                on_events=on_events,
+                on_crons=on_crons,
+                sticky=sticky,
+                concurrency=concurrency,
+                input_validator=input_validator
+                or cast(Type[TWorkflowInput], EmptyModel),
+                task_defaults=task_defaults,
+            ),
+            self,
+        )
+
+    @overload
+    def task(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: None = None,
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        retries: int = 0,
+        rate_limits: list[RateLimit] = [],
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        backoff_factor: float | None = None,
+        backoff_max_seconds: int | None = None,
+    ) -> Callable[[Callable[[EmptyModel, Context], R]], Standalone[EmptyModel, R]]: ...
+
+    @overload
+    def task(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: Type[TWorkflowInput],
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        retries: int = 0,
+        rate_limits: list[RateLimit] = [],
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        backoff_factor: float | None = None,
+        backoff_max_seconds: int | None = None,
+    ) -> Callable[
+        [Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]
+    ]: ...
+
+    def task(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: Type[TWorkflowInput] | None = None,
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        retries: int = 0,
+        rate_limits: list[RateLimit] = [],
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        backoff_factor: float | None = None,
+        backoff_max_seconds: int | None = None,
+    ) -> (
+        Callable[[Callable[[EmptyModel, Context], R]], Standalone[EmptyModel, R]]
+        | Callable[
+            [Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]
+        ]
+    ):
+        """
+        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 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_crons: A list of cron triggers for the task. Defaults to an empty list.
+        :type on_crons: list[str]
+
+        :param version: A version for the task. Default: None
+        :type version: str | None
+
+        :param sticky: A sticky strategy for the task. Default: None
+        :type sticky: StickyStrategy | None
+
+        :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 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 execution_timeout: The maximum time allowed for executing the task. Default: DEFAULT_EXECUTION_TIMEOUT
+        :type execution_timeout: Duration
+
+        :param retries: The number of times to retry the task before failing. Default: 0
+        :type retries: int
+
+        :param rate_limits: A list of rate limit configurations for the task. Defaults to an empty list.
+        :type rate_limits: list[RateLimit]
+
+        :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_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue. Default: None
+        :type backoff_max_seconds: int | None
+
+        :returns: A decorator which creates a `Standalone` task object.
+        :rtype: Callable[[Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]]
+        """
+
+        workflow = Workflow[TWorkflowInput](
+            WorkflowConfig(
+                name=name,
+                version=version,
+                description=description,
+                on_events=on_events,
+                on_crons=on_crons,
+                sticky=sticky,
+                concurrency=concurrency,
+                input_validator=input_validator
+                or cast(Type[TWorkflowInput], EmptyModel),
+            ),
+            self,
+        )
+
+        task_wrapper = workflow.task(
+            name=name,
+            schedule_timeout=schedule_timeout,
+            execution_timeout=execution_timeout,
+            parents=[],
+            retries=retries,
+            rate_limits=rate_limits,
+            desired_worker_labels=desired_worker_labels,
+            backoff_factor=backoff_factor,
+            backoff_max_seconds=backoff_max_seconds,
+            concurrency=[concurrency] if concurrency else [],
+        )
+
+        def inner(
+            func: Callable[[TWorkflowInput, Context], R]
+        ) -> Standalone[TWorkflowInput, R]:
+            created_task = task_wrapper(func)
+
+            return Standalone[TWorkflowInput, R](
+                workflow=workflow,
+                task=created_task,
+            )
+
+        return inner
+
+    @overload
+    def durable_task(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: None = None,
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        retries: int = 0,
+        rate_limits: list[RateLimit] = [],
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        backoff_factor: float | None = None,
+        backoff_max_seconds: int | None = None,
+    ) -> Callable[
+        [Callable[[EmptyModel, DurableContext], R]], Standalone[EmptyModel, R]
+    ]: ...
+
+    @overload
+    def durable_task(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: Type[TWorkflowInput],
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        retries: int = 0,
+        rate_limits: list[RateLimit] = [],
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        backoff_factor: float | None = None,
+        backoff_max_seconds: int | None = None,
+    ) -> Callable[
+        [Callable[[TWorkflowInput, DurableContext], R]], Standalone[TWorkflowInput, R]
+    ]: ...
+
+    def durable_task(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        input_validator: Type[TWorkflowInput] | None = None,
+        on_events: list[str] = [],
+        on_crons: list[str] = [],
+        version: str | None = None,
+        sticky: StickyStrategy | None = None,
+        default_priority: int = 1,
+        concurrency: ConcurrencyExpression | None = None,
+        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        retries: int = 0,
+        rate_limits: list[RateLimit] = [],
+        desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
+        backoff_factor: float | None = None,
+        backoff_max_seconds: int | None = None,
+    ) -> (
+        Callable[[Callable[[EmptyModel, DurableContext], R]], Standalone[EmptyModel, R]]
+        | Callable[
+            [Callable[[TWorkflowInput, DurableContext], R]],
+            Standalone[TWorkflowInput, R],
+        ]
+    ):
+        """
+        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 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_crons: A list of cron triggers for the task. Defaults to an empty list.
+        :type on_crons: list[str]
+
+        :param version: A version for the task. Default: None
+        :type version: str | None
+
+        :param sticky: A sticky strategy for the task. Default: None
+        :type sticky: StickyStrategy | None
+
+        :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 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 execution_timeout: The maximum time allowed for executing the task. Default: DEFAULT_EXECUTION_TIMEOUT
+        :type execution_timeout: Duration
+
+        :param retries: The number of times to retry the task before failing. Default: 0
+        :type retries: int
+
+        :param rate_limits: A list of rate limit configurations for the task. Defaults to an empty list.
+        :type rate_limits: list[RateLimit]
+
+        :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_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue. Default: None
+        :type backoff_max_seconds: int | None
+
+        :returns: A decorator which creates a `Standalone` task object.
+        :rtype: Callable[[Callable[[TWorkflowInput, Context], R]], Standalone[TWorkflowInput, R]]
+        """
+
+        workflow = Workflow[TWorkflowInput](
+            WorkflowConfig(
+                name=name,
+                version=version,
+                description=description,
+                on_events=on_events,
+                on_crons=on_crons,
+                sticky=sticky,
+                concurrency=concurrency,
+                input_validator=input_validator
+                or cast(Type[TWorkflowInput], EmptyModel),
+            ),
+            self,
+        )
+
+        task_wrapper = workflow.durable_task(
+            name=name,
+            schedule_timeout=schedule_timeout,
+            execution_timeout=execution_timeout,
+            parents=[],
+            retries=retries,
+            rate_limits=rate_limits,
+            desired_worker_labels=desired_worker_labels,
+            backoff_factor=backoff_factor,
+            backoff_max_seconds=backoff_max_seconds,
+            concurrency=[concurrency] if concurrency else [],
+        )
+
+        def inner(
+            func: Callable[[TWorkflowInput, DurableContext], R]
+        ) -> Standalone[TWorkflowInput, R]:
+            created_task = task_wrapper(func)
+
+            return Standalone[TWorkflowInput, R](
+                workflow=workflow,
+                task=created_task,
+            )
+
+        return inner