hatchet-sdk 0.40.0a8__py3-none-any.whl → 0.41.0__py3-none-any.whl

hatchet_sdk/clients/rest/rest.py

@@ -81,7 +81,7 @@ class RESTClientObject:
             self.retry_client = aiohttp_retry.RetryClient(
                 client_session=self.pool_manager,
                 retry_options=aiohttp_retry.ExponentialRetry(
-                    attempts=retries, factor=0.0, start_timeout=0.0, max_timeout=120.0
+                    attempts=retries, factor=2.0, start_timeout=0.1, max_timeout=120.0
                 ),
             )
         else:
@@ -164,10 +164,10 @@ class RESTClientObject:
                         data.add_field(k, v)
                 args["data"] = data
 
-            # Pass a `bytes` parameter directly in the body to support
+            # Pass a `bytes` or `str` parameter directly in the body to support
             # other content types than Json when `body` argument is provided
             # in serialized form
-            elif isinstance(body, bytes):
+            elif isinstance(body, str) or isinstance(body, bytes):
                 args["data"] = body
             else:
                 # Cannot generate the request from given parameters

hatchet_sdk/clients/rest_client.py

@@ -1,13 +1,11 @@
 import asyncio
 import atexit
+import datetime
 import threading
-from typing import Any
+from typing import Any, Coroutine, List
+
+from pydantic import StrictInt
 
-from hatchet_sdk.clients.cloud_rest.api.managed_worker_api import ManagedWorkerApi
-from hatchet_sdk.clients.cloud_rest.api_client import ApiClient as CloudApiClient
-from hatchet_sdk.clients.cloud_rest.configuration import (
-    Configuration as CloudConfiguration,
-)
 from hatchet_sdk.clients.rest.api.event_api import EventApi
 from hatchet_sdk.clients.rest.api.log_api import LogApi
 from hatchet_sdk.clients.rest.api.step_run_api import StepRunApi
@@ -17,6 +15,13 @@ from hatchet_sdk.clients.rest.api.workflow_runs_api import WorkflowRunsApi
 from hatchet_sdk.clients.rest.api_client import ApiClient
 from hatchet_sdk.clients.rest.configuration import Configuration
 from hatchet_sdk.clients.rest.models import TriggerWorkflowRunRequest
+from hatchet_sdk.clients.rest.models.create_cron_workflow_trigger_request import (
+    CreateCronWorkflowTriggerRequest,
+)
+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.event_list import EventList
 from hatchet_sdk.clients.rest.models.event_order_by_direction import (
     EventOrderByDirection,
@@ -35,6 +40,13 @@ from hatchet_sdk.clients.rest.models.replay_workflow_runs_request import (
 from hatchet_sdk.clients.rest.models.replay_workflow_runs_response import (
     ReplayWorkflowRunsResponse,
 )
+from hatchet_sdk.clients.rest.models.schedule_workflow_run_request import (
+    ScheduleWorkflowRunRequest,
+)
+from hatchet_sdk.clients.rest.models.scheduled_workflows import ScheduledWorkflows
+from hatchet_sdk.clients.rest.models.scheduled_workflows_order_by_field import (
+    ScheduledWorkflowsOrderByField,
+)
 from hatchet_sdk.clients.rest.models.workflow import Workflow
 from hatchet_sdk.clients.rest.models.workflow_kind import WorkflowKind
 from hatchet_sdk.clients.rest.models.workflow_list import WorkflowList
@@ -65,15 +77,7 @@ class AsyncRestApi:
             access_token=api_key,
         )
 
-        self.cloud_config = CloudConfiguration(
-            host=host,
-            access_token=api_key,
-        )
-
         self._api_client = None
-        self._cloud_api_client = None
-        self._managed_worker_api = None
-
         self._workflow_api = None
         self._workflow_run_api = None
         self._step_run_api = None
@@ -84,15 +88,8 @@ class AsyncRestApi:
     def api_client(self):
         if self._api_client is None:
             self._api_client = ApiClient(configuration=self.config)
-            self._cloud_api_client = CloudApiClient(configuration=self.cloud_config)
         return self._api_client
 
-    @property
-    def managed_worker_api(self):
-        if self._managed_worker_api is None:
-            self._managed_worker_api = ManagedWorkerApi(self.api_client)
-        return self._managed_worker_api
-
     @property
     def workflow_api(self):
         if self._workflow_api is None:
@@ -223,9 +220,112 @@ class AsyncRestApi:
             version=version,
             trigger_workflow_run_request=TriggerWorkflowRunRequest(
                 input=input,
+                additional_metadata=additional_metadata,
+            ),
+        )
+
+    async def cron_create(
+        self,
+        workflow_name: str,
+        cron_name: str,
+        expression: str,
+        input: dict[str, Any],
+        additional_metadata: dict[str, str],
+    ):
+        return await self.workflow_run_api.cron_workflow_trigger_create(
+            tenant=self.tenant_id,
+            workflow=workflow_name,
+            create_cron_workflow_trigger_request=CreateCronWorkflowTriggerRequest(
+                cronName=cron_name,
+                expression=expression,
+                input=input,
+                additional_metadata=additional_metadata,
+            ),
+        )
+
+    async def cron_delete(self, cron_trigger_id: str):
+        return await self.workflow_api.workflow_cron_delete(
+            tenant=self.tenant_id,
+            cron_workflow=cron_trigger_id,
+        )
+
+    async def cron_list(
+        self,
+        offset: StrictInt | None = None,
+        limit: StrictInt | None = None,
+        workflow_id: str | None = None,
+        additional_metadata: list[str] | None = None,
+        order_by_field: CronWorkflowsOrderByField | None = None,
+        order_by_direction: WorkflowRunOrderByDirection | None = None,
+    ):
+        return await self.workflow_api.cron_workflow_list(
+            tenant=self.tenant_id,
+            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 cron_get(self, cron_trigger_id: str):
+        return await self.workflow_api.workflow_cron_get(
+            tenant=self.tenant_id,
+            cron_workflow=cron_trigger_id,
+        )
+
+    async def schedule_create(
+        self,
+        name: str,
+        trigger_at: datetime.datetime,
+        input: dict[str, Any],
+        additional_metadata: dict[str, str],
+    ):
+        return await self.workflow_run_api.scheduled_workflow_run_create(
+            tenant=self.tenant_id,
+            workflow=name,
+            create_schedule_workflow_trigger_request=ScheduleWorkflowRunRequest(
+                triggerAt=trigger_at,
+                input=input,
+                additional_metadata=additional_metadata,
             ),
         )
 
+    async def schedule_delete(self, scheduled_trigger_id: str):
+        return await self.workflow_api.workflow_scheduled_delete(
+            tenant=self.tenant_id,
+            scheduled_workflow_run=scheduled_trigger_id,
+        )
+
+    async def schedule_list(
+        self,
+        offset: StrictInt | None = None,
+        limit: StrictInt | None = None,
+        workflow_id: str | None = None,
+        additional_metadata: list[str] | None = None,
+        parent_workflow_run_id: str | None = None,
+        parent_step_run_id: str | None = None,
+        order_by_field: ScheduledWorkflowsOrderByField | None = None,
+        order_by_direction: WorkflowRunOrderByDirection | None = None,
+    ):
+        return await self.workflow_api.workflow_scheduled_list(
+            tenant=self.tenant_id,
+            offset=offset,
+            limit=limit,
+            workflow_id=workflow_id,
+            parent_workflow_run_id=parent_workflow_run_id,
+            parent_step_run_id=parent_step_run_id,
+            additional_metadata=additional_metadata,
+            order_by_field=order_by_field,
+            order_by_direction=order_by_direction,
+        )
+
+    async def schedule_get(self, scheduled_trigger_id: str):
+        return await self.workflow_api.workflow_scheduled_get(
+            tenant=self.tenant_id,
+            scheduled_workflow_run=scheduled_trigger_id,
+        )
+
     async def list_logs(
         self,
         step_run_id: str,
@@ -380,6 +480,85 @@ class RestApi:
             )
         )
 
+    def cron_create(
+        self,
+        workflow_name: str,
+        cron_name: str,
+        expression: str,
+        input: dict[str, Any],
+        additional_metadata: dict[str, str],
+    ) -> CronWorkflows:
+        return self._run_coroutine(
+            self.aio.cron_create(
+                workflow_name, cron_name, expression, input, additional_metadata
+            )
+        )
+
+    def cron_delete(self, cron_trigger_id: str):
+        return self._run_coroutine(self.aio.cron_delete(cron_trigger_id))
+
+    def cron_list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        workflow_id: str | None = None,
+        additional_metadata: list[str] | None = None,
+        order_by_field: CronWorkflowsOrderByField | None = None,
+        order_by_direction: WorkflowRunOrderByDirection | None = None,
+    ):
+        return self._run_coroutine(
+            self.aio.cron_list(
+                offset,
+                limit,
+                workflow_id,
+                additional_metadata,
+                order_by_field,
+                order_by_direction,
+            )
+        )
+
+    def cron_get(self, cron_trigger_id: str):
+        return self._run_coroutine(self.aio.cron_get(cron_trigger_id))
+
+    def schedule_create(
+        self,
+        workflow_name: str,
+        trigger_at: datetime.datetime,
+        input: dict[str, Any],
+        additional_metadata: dict[str, str],
+    ):
+        return self._run_coroutine(
+            self.aio.schedule_create(
+                workflow_name, trigger_at, input, additional_metadata
+            )
+        )
+
+    def schedule_delete(self, scheduled_trigger_id: str):
+        return self._run_coroutine(self.aio.schedule_delete(scheduled_trigger_id))
+
+    def schedule_list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        workflow_id: str | None = None,
+        additional_metadata: list[str] | None = None,
+        order_by_field: CronWorkflowsOrderByField | None = None,
+        order_by_direction: WorkflowRunOrderByDirection | None = None,
+    ):
+        return self._run_coroutine(
+            self.aio.schedule_list(
+                offset,
+                limit,
+                workflow_id,
+                additional_metadata,
+                order_by_field,
+                order_by_direction,
+            )
+        )
+
+    def schedule_get(self, scheduled_trigger_id: str):
+        return self._run_coroutine(self.aio.schedule_get(scheduled_trigger_id))
+
     def list_logs(
         self,
         step_run_id: str,

hatchet_sdk/contracts/dispatcher_pb2.pyi

@@ -1,3 +1,5 @@
+# type: ignore
+
 from google.protobuf import timestamp_pb2 as _timestamp_pb2
 from google.protobuf.internal import containers as _containers
 from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper

hatchet_sdk/contracts/events_pb2.pyi

@@ -1,3 +1,5 @@
+# type: ignore
+
 from google.protobuf import timestamp_pb2 as _timestamp_pb2
 from google.protobuf.internal import containers as _containers
 from google.protobuf import descriptor as _descriptor

hatchet_sdk/contracts/workflows_pb2.pyi

@@ -1,3 +1,5 @@
+# type: ignore
+
 from google.protobuf import timestamp_pb2 as _timestamp_pb2
 from google.protobuf.internal import containers as _containers
 from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper

hatchet_sdk/features/cron.py

@@ -0,0 +1,286 @@
+from typing import Union
+
+from pydantic import BaseModel, field_validator
+
+from hatchet_sdk.client import Client
+from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
+from hatchet_sdk.clients.rest.models.cron_workflows_list import CronWorkflowsList
+from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
+    CronWorkflowsOrderByField,
+)
+from hatchet_sdk.clients.rest.models.workflow_run_order_by_direction import (
+    WorkflowRunOrderByDirection,
+)
+
+
+class CreateCronTriggerInput(BaseModel):
+    """
+    Schema for creating a workflow run triggered by a cron.
+
+    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"}).
+    """
+
+    expression: str = None
+    input: dict = {}
+    additional_metadata: dict[str, str] = {}
+
+    @field_validator("expression")
+    def validate_cron_expression(cls, v):
+        """
+        Validates the cron expression to ensure it adheres to the expected format.
+
+        Args:
+            v (str): The cron expression to validate.
+
+        Raises:
+            ValueError: If the expression is invalid.
+
+        Returns:
+            str: The validated cron expression.
+        """
+        if not v:
+            raise ValueError("Cron expression is required")
+
+        parts = v.split()
+        if len(parts) != 5:
+            raise ValueError(
+                "Cron expression must have 5 parts: minute hour day month weekday"
+            )
+
+        for part in parts:
+            if not (
+                part == "*"
+                or part.replace("*/", "").replace("-", "").replace(",", "").isdigit()
+            ):
+                raise ValueError(f"Invalid cron expression part: {part}")
+
+        return v
+
+
+class CronClient:
+    """
+    Client for managing workflow cron triggers synchronously.
+
+    Attributes:
+        _client (Client): The underlying client used to interact with the REST API.
+        aio (CronClientAsync): Asynchronous counterpart of CronClient.
+    """
+
+    _client: Client
+
+    def __init__(self, _client: Client):
+        """
+        Initializes the CronClient with a given Client instance.
+
+        Args:
+            _client (Client): The client instance to be used for REST interactions.
+        """
+        self._client = _client
+        self.aio = CronClientAsync(_client)
+
+    def create(
+        self,
+        workflow_name: str,
+        cron_name: str,
+        expression: str,
+        input: dict,
+        additional_metadata: dict[str, str],
+    ) -> CronWorkflows:
+        """
+        Creates a new workflow cron trigger.
+
+        Args:
+            workflow_name (str): The name of the workflow to trigger.
+            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"}).
+
+        Returns:
+            CronWorkflows: The created cron workflow instance.
+        """
+        validated_input = CreateCronTriggerInput(
+            expression=expression, input=input, additional_metadata=additional_metadata
+        )
+
+        return self._client.rest.cron_create(
+            workflow_name,
+            cron_name,
+            validated_input.expression,
+            validated_input.input,
+            validated_input.additional_metadata,
+        )
+
+    def delete(self, cron_trigger: Union[str, CronWorkflows]) -> None:
+        """
+        Deletes a workflow cron trigger.
+
+        Args:
+            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to delete.
+        """
+        id_ = cron_trigger
+        if isinstance(cron_trigger, CronWorkflows):
+            id_ = cron_trigger.metadata.id
+        self._client.rest.cron_delete(id_)
+
+    def list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        workflow_id: str | None = None,
+        additional_metadata: list[str] | None = None,
+        order_by_field: CronWorkflowsOrderByField | None = None,
+        order_by_direction: WorkflowRunOrderByDirection | None = None,
+    ) -> CronWorkflowsList:
+        """
+        Retrieves a list of all workflow cron triggers matching the criteria.
+
+        Args:
+            offset (int | None): The offset to start the list from.
+            limit (int | None): The maximum number of items to return.
+            workflow_id (str | None): The ID of the workflow to filter by.
+            additional_metadata (list[str] | None): Filter by additional metadata keys (e.g. ["key1:value1", "key2:value2"]).
+            order_by_field (CronWorkflowsOrderByField | None): The field to order the list by.
+            order_by_direction (WorkflowRunOrderByDirection | None): The direction to order the list by.
+
+        Returns:
+            CronWorkflowsList: A list of cron workflows.
+        """
+        return self._client.rest.cron_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, cron_trigger: Union[str, CronWorkflows]) -> CronWorkflows:
+        """
+        Retrieves a specific workflow cron trigger by ID.
+
+        Args:
+            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to retrieve.
+
+        Returns:
+            CronWorkflows: The requested cron workflow instance.
+        """
+        id_ = cron_trigger
+        if isinstance(cron_trigger, CronWorkflows):
+            id_ = cron_trigger.metadata.id
+        return self._client.rest.cron_get(id_)
+
+
+class CronClientAsync:
+    """
+    Asynchronous client for managing workflow cron triggers.
+
+    Attributes:
+        _client (Client): The underlying client used to interact with the REST API asynchronously.
+    """
+
+    _client: Client
+
+    def __init__(self, _client: Client):
+        """
+        Initializes the CronClientAsync 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,
+        cron_name: str,
+        expression: str,
+        input: dict,
+        additional_metadata: dict[str, str],
+    ) -> CronWorkflows:
+        """
+        Asynchronously creates a new workflow cron trigger.
+
+        Args:
+            workflow_name (str): The name of the workflow to trigger.
+            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"}).
+
+        Returns:
+            CronWorkflows: The created cron workflow instance.
+        """
+        validated_input = CreateCronTriggerInput(
+            expression=expression, input=input, additional_metadata=additional_metadata
+        )
+
+        return await self._client.rest.aio.cron_create(
+            workflow_name=workflow_name,
+            cron_name=cron_name,
+            expression=validated_input.expression,
+            input=validated_input.input,
+            additional_metadata=validated_input.additional_metadata,
+        )
+
+    async def delete(self, cron_trigger: Union[str, CronWorkflows]) -> None:
+        """
+        Asynchronously deletes a workflow cron trigger.
+
+        Args:
+            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to delete.
+        """
+        id_ = cron_trigger
+        if isinstance(cron_trigger, CronWorkflows):
+            id_ = cron_trigger.metadata.id
+        await self._client.rest.aio.cron_delete(id_)
+
+    async def list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        workflow_id: str | None = None,
+        additional_metadata: list[str] | None = None,
+        order_by_field: CronWorkflowsOrderByField | None = None,
+        order_by_direction: WorkflowRunOrderByDirection | None = None,
+    ) -> CronWorkflowsList:
+        """
+        Asynchronously retrieves a list of all workflow cron triggers matching the criteria.
+
+        Args:
+            offset (int | None): The offset to start the list from.
+            limit (int | None): The maximum number of items to return.
+            workflow_id (str | None): The ID of the workflow to filter by.
+            additional_metadata (list[str] | None): Filter by additional metadata keys (e.g. ["key1:value1", "key2:value2"]).
+            order_by_field (CronWorkflowsOrderByField | None): The field to order the list by.
+            order_by_direction (WorkflowRunOrderByDirection | None): The direction to order the list by.
+
+        Returns:
+            CronWorkflowsList: A list of cron workflows.
+        """
+        return await self._client.rest.aio.cron_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, cron_trigger: Union[str, CronWorkflows]) -> CronWorkflows:
+        """
+        Asynchronously retrieves a specific workflow cron trigger by ID.
+
+        Args:
+            cron_trigger (Union[str, CronWorkflows]): The cron trigger ID or CronWorkflows instance to retrieve.
+
+        Returns:
+            CronWorkflows: The requested cron workflow instance.
+        """
+        id_ = cron_trigger
+        if isinstance(cron_trigger, CronWorkflows):
+            id_ = cron_trigger.metadata.id
+        return await self._client.rest.aio.cron_get(id_)