hatchet-sdk 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

hatchet_sdk/clients/rest/__init__.py

@@ -245,6 +245,8 @@ from hatchet_sdk.clients.rest.models.v1_task_run_status import V1TaskRunStatus
 from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
 from hatchet_sdk.clients.rest.models.v1_task_summary import V1TaskSummary
 from hatchet_sdk.clients.rest.models.v1_task_summary_list import V1TaskSummaryList
+from hatchet_sdk.clients.rest.models.v1_task_timing import V1TaskTiming
+from hatchet_sdk.clients.rest.models.v1_task_timing_list import V1TaskTimingList
 from hatchet_sdk.clients.rest.models.v1_trigger_workflow_run_request import (
     V1TriggerWorkflowRunRequest,
 )

hatchet_sdk/clients/rest/api/task_api.py

@@ -1555,6 +1555,9 @@ class TaskApi:
         since: Annotated[
             datetime, Field(description="The start time to get metrics for")
         ],
+        until: Annotated[
+            Optional[datetime], Field(description="The end time to get metrics for")
+        ] = None,
         workflow_ids: Annotated[
             Optional[
                 List[Annotated[str, Field(min_length=36, strict=True, max_length=36)]]
@@ -1585,6 +1588,8 @@ class TaskApi:
         :type tenant: str
         :param since: The start time to get metrics for (required)
         :type since: datetime
+        :param until: The end time to get metrics for
+        :type until: datetime
         :param workflow_ids: The workflow id to find runs for
         :type workflow_ids: List[str]
         :param parent_task_external_id: The parent task's external id
@@ -1614,6 +1619,7 @@ class TaskApi:
         _param = self._v1_task_list_status_metrics_serialize(
             tenant=tenant,
             since=since,
+            until=until,
             workflow_ids=workflow_ids,
             parent_task_external_id=parent_task_external_id,
             _request_auth=_request_auth,
@@ -1649,6 +1655,9 @@ class TaskApi:
         since: Annotated[
             datetime, Field(description="The start time to get metrics for")
         ],
+        until: Annotated[
+            Optional[datetime], Field(description="The end time to get metrics for")
+        ] = None,
         workflow_ids: Annotated[
             Optional[
                 List[Annotated[str, Field(min_length=36, strict=True, max_length=36)]]
@@ -1679,6 +1688,8 @@ class TaskApi:
         :type tenant: str
         :param since: The start time to get metrics for (required)
         :type since: datetime
+        :param until: The end time to get metrics for
+        :type until: datetime
         :param workflow_ids: The workflow id to find runs for
         :type workflow_ids: List[str]
         :param parent_task_external_id: The parent task's external id
@@ -1708,6 +1719,7 @@ class TaskApi:
         _param = self._v1_task_list_status_metrics_serialize(
             tenant=tenant,
             since=since,
+            until=until,
             workflow_ids=workflow_ids,
             parent_task_external_id=parent_task_external_id,
             _request_auth=_request_auth,
@@ -1743,6 +1755,9 @@ class TaskApi:
         since: Annotated[
             datetime, Field(description="The start time to get metrics for")
         ],
+        until: Annotated[
+            Optional[datetime], Field(description="The end time to get metrics for")
+        ] = None,
         workflow_ids: Annotated[
             Optional[
                 List[Annotated[str, Field(min_length=36, strict=True, max_length=36)]]
@@ -1773,6 +1788,8 @@ class TaskApi:
         :type tenant: str
         :param since: The start time to get metrics for (required)
         :type since: datetime
+        :param until: The end time to get metrics for
+        :type until: datetime
         :param workflow_ids: The workflow id to find runs for
         :type workflow_ids: List[str]
         :param parent_task_external_id: The parent task's external id
@@ -1802,6 +1819,7 @@ class TaskApi:
         _param = self._v1_task_list_status_metrics_serialize(
             tenant=tenant,
             since=since,
+            until=until,
             workflow_ids=workflow_ids,
             parent_task_external_id=parent_task_external_id,
             _request_auth=_request_auth,
@@ -1825,6 +1843,7 @@ class TaskApi:
         self,
         tenant,
         since,
+        until,
         workflow_ids,
         parent_task_external_id,
         _request_auth,
@@ -1863,6 +1882,17 @@ class TaskApi:
             else:
                 _query_params.append(("since", since))
 
+        if until is not None:
+            if isinstance(until, datetime):
+                _query_params.append(
+                    (
+                        "until",
+                        until.strftime(self.api_client.configuration.datetime_format),
+                    )
+                )
+            else:
+                _query_params.append(("until", until))
+
         if workflow_ids is not None:
 
             _query_params.append(("workflow_ids", workflow_ids))

hatchet_sdk/clients/rest/api/workflow_runs_api.py

@@ -23,6 +23,7 @@ from hatchet_sdk.clients.rest.api_response import ApiResponse
 from hatchet_sdk.clients.rest.models.v1_task_event_list import V1TaskEventList
 from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
 from hatchet_sdk.clients.rest.models.v1_task_summary_list import V1TaskSummaryList
+from hatchet_sdk.clients.rest.models.v1_task_timing_list import V1TaskTimingList
 from hatchet_sdk.clients.rest.models.v1_trigger_workflow_run_request import (
     V1TriggerWorkflowRunRequest,
 )
@@ -914,6 +915,304 @@ class WorkflowRunsApi:
             _request_auth=_request_auth,
         )
 
+    @validate_call
+    def v1_workflow_run_get_timings(
+        self,
+        v1_workflow_run: Annotated[
+            str,
+            Field(
+                min_length=36,
+                strict=True,
+                max_length=36,
+                description="The workflow run id to get",
+            ),
+        ],
+        depth: Annotated[
+            Optional[StrictInt], Field(description="The depth to retrieve children")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> V1TaskTimingList:
+        """List timings for a workflow run
+
+        Get the timings for a workflow run
+
+        :param v1_workflow_run: The workflow run id to get (required)
+        :type v1_workflow_run: str
+        :param depth: The depth to retrieve children
+        :type depth: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._v1_workflow_run_get_timings_serialize(
+            v1_workflow_run=v1_workflow_run,
+            depth=depth,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1TaskTimingList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+            "501": "APIErrors",
+        }
+        response_data = self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+    @validate_call
+    def v1_workflow_run_get_timings_with_http_info(
+        self,
+        v1_workflow_run: Annotated[
+            str,
+            Field(
+                min_length=36,
+                strict=True,
+                max_length=36,
+                description="The workflow run id to get",
+            ),
+        ],
+        depth: Annotated[
+            Optional[StrictInt], Field(description="The depth to retrieve children")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[V1TaskTimingList]:
+        """List timings for a workflow run
+
+        Get the timings for a workflow run
+
+        :param v1_workflow_run: The workflow run id to get (required)
+        :type v1_workflow_run: str
+        :param depth: The depth to retrieve children
+        :type depth: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._v1_workflow_run_get_timings_serialize(
+            v1_workflow_run=v1_workflow_run,
+            depth=depth,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1TaskTimingList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+            "501": "APIErrors",
+        }
+        response_data = self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def v1_workflow_run_get_timings_without_preload_content(
+        self,
+        v1_workflow_run: Annotated[
+            str,
+            Field(
+                min_length=36,
+                strict=True,
+                max_length=36,
+                description="The workflow run id to get",
+            ),
+        ],
+        depth: Annotated[
+            Optional[StrictInt], Field(description="The depth to retrieve children")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """List timings for a workflow run
+
+        Get the timings for a workflow run
+
+        :param v1_workflow_run: The workflow run id to get (required)
+        :type v1_workflow_run: str
+        :param depth: The depth to retrieve children
+        :type depth: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._v1_workflow_run_get_timings_serialize(
+            v1_workflow_run=v1_workflow_run,
+            depth=depth,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "V1TaskTimingList",
+            "400": "APIErrors",
+            "403": "APIErrors",
+            "501": "APIErrors",
+        }
+        response_data = self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+    def _v1_workflow_run_get_timings_serialize(
+        self,
+        v1_workflow_run,
+        depth,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {}
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if v1_workflow_run is not None:
+            _path_params["v1-workflow-run"] = v1_workflow_run
+        # process the query parameters
+        if depth is not None:
+
+            _query_params.append(("depth", depth))
+
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+        # set the HTTP header `Accept`
+        if "Accept" not in _header_params:
+            _header_params["Accept"] = self.api_client.select_header_accept(
+                ["application/json"]
+            )
+
+        # authentication setting
+        _auth_settings: List[str] = ["cookieAuth", "bearerAuth"]
+
+        return self.api_client.param_serialize(
+            method="GET",
+            resource_path="/api/v1/stable/workflow-runs/{v1-workflow-run}/task-timings",
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth,
+        )
+
     @validate_call
     def v1_workflow_run_list(
         self,

hatchet_sdk/clients/rest/api_client.py

@@ -40,6 +40,7 @@ from hatchet_sdk.clients.rest.exceptions import (
     ServiceException,
     UnauthorizedException,
 )
+from hatchet_sdk.logger import logger
 
 RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
 
@@ -356,7 +357,20 @@ class ApiClient:
             return [self.sanitize_for_serialization(sub_obj) for sub_obj in obj]
         elif isinstance(obj, tuple):
             return tuple(self.sanitize_for_serialization(sub_obj) for sub_obj in obj)
-        elif isinstance(obj, (datetime.datetime, datetime.date)):
+        ## IMPORTANT: Checking `datetime` must come before `date` since `datetime` is a subclass of `date`
+        elif isinstance(obj, datetime.datetime):
+            if not obj.tzinfo:
+                current_tz = (
+                    datetime.datetime.now(datetime.timezone(datetime.timedelta(0)))
+                    .astimezone()
+                    .tzinfo
+                    or datetime.timezone.utc
+                )
+                logger.warning(f"timezone-naive datetime found. assuming {current_tz}.")
+                obj = obj.replace(tzinfo=current_tz)
+
+            return obj.isoformat()
+        elif isinstance(obj, datetime.date):
             return obj.isoformat()
         elif isinstance(obj, decimal.Decimal):
             return str(obj)

hatchet_sdk/clients/rest/models/__init__.py

@@ -210,6 +210,8 @@ from hatchet_sdk.clients.rest.models.v1_task_run_status import V1TaskRunStatus
 from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
 from hatchet_sdk.clients.rest.models.v1_task_summary import V1TaskSummary
 from hatchet_sdk.clients.rest.models.v1_task_summary_list import V1TaskSummaryList
+from hatchet_sdk.clients.rest.models.v1_task_timing import V1TaskTiming
+from hatchet_sdk.clients.rest.models.v1_task_timing_list import V1TaskTimingList
 from hatchet_sdk.clients.rest.models.v1_trigger_workflow_run_request import (
     V1TriggerWorkflowRunRequest,
 )

hatchet_sdk/clients/rest/models/v1_task_summary.py

@@ -95,10 +95,8 @@ class V1TaskSummary(BaseModel):
     )
     workflow_id: StrictStr = Field(alias="workflowId")
     workflow_name: Optional[StrictStr] = Field(default=None, alias="workflowName")
-    workflow_run_external_id: Optional[StrictStr] = Field(
-        default=None,
-        description="The external ID of the workflow run",
-        alias="workflowRunExternalId",
+    workflow_run_external_id: StrictStr = Field(
+        description="The external ID of the workflow run", alias="workflowRunExternalId"
     )
     workflow_version_id: Optional[StrictStr] = Field(
         default=None,

hatchet_sdk/clients/rest/models/v1_task_timing.py

@@ -0,0 +1,159 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from datetime import datetime
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing_extensions import Annotated, Self
+
+from hatchet_sdk.clients.rest.models.api_resource_meta import APIResourceMeta
+from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
+
+
+class V1TaskTiming(BaseModel):
+    """
+    V1TaskTiming
+    """  # noqa: E501
+
+    metadata: APIResourceMeta
+    depth: StrictInt = Field(description="The depth of the task in the waterfall.")
+    status: V1TaskStatus
+    task_display_name: StrictStr = Field(
+        description="The display name of the task run.", alias="taskDisplayName"
+    )
+    task_external_id: Annotated[
+        str, Field(min_length=36, strict=True, max_length=36)
+    ] = Field(description="The external ID of the task.", alias="taskExternalId")
+    task_id: StrictInt = Field(description="The ID of the task.", alias="taskId")
+    task_inserted_at: datetime = Field(
+        description="The timestamp the task was inserted.", alias="taskInsertedAt"
+    )
+    tenant_id: Annotated[str, Field(min_length=36, strict=True, max_length=36)] = Field(
+        description="The ID of the tenant.", alias="tenantId"
+    )
+    parent_task_external_id: Optional[
+        Annotated[str, Field(min_length=36, strict=True, max_length=36)]
+    ] = Field(
+        default=None,
+        description="The external ID of the parent task.",
+        alias="parentTaskExternalId",
+    )
+    queued_at: Optional[datetime] = Field(
+        default=None,
+        description="The timestamp the task run was queued.",
+        alias="queuedAt",
+    )
+    started_at: Optional[datetime] = Field(
+        default=None,
+        description="The timestamp the task run started.",
+        alias="startedAt",
+    )
+    finished_at: Optional[datetime] = Field(
+        default=None,
+        description="The timestamp the task run finished.",
+        alias="finishedAt",
+    )
+    __properties: ClassVar[List[str]] = [
+        "metadata",
+        "depth",
+        "status",
+        "taskDisplayName",
+        "taskExternalId",
+        "taskId",
+        "taskInsertedAt",
+        "tenantId",
+        "parentTaskExternalId",
+        "queuedAt",
+        "startedAt",
+        "finishedAt",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1TaskTiming from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of metadata
+        if self.metadata:
+            _dict["metadata"] = self.metadata.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1TaskTiming from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "metadata": (
+                    APIResourceMeta.from_dict(obj["metadata"])
+                    if obj.get("metadata") is not None
+                    else None
+                ),
+                "depth": obj.get("depth"),
+                "status": obj.get("status"),
+                "taskDisplayName": obj.get("taskDisplayName"),
+                "taskExternalId": obj.get("taskExternalId"),
+                "taskId": obj.get("taskId"),
+                "taskInsertedAt": obj.get("taskInsertedAt"),
+                "tenantId": obj.get("tenantId"),
+                "parentTaskExternalId": obj.get("parentTaskExternalId"),
+                "queuedAt": obj.get("queuedAt"),
+                "startedAt": obj.get("startedAt"),
+                "finishedAt": obj.get("finishedAt"),
+            }
+        )
+        return _obj

hatchet_sdk/clients/rest/models/v1_task_timing_list.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    Hatchet API
+
+    The Hatchet API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
+
+from hatchet_sdk.clients.rest.models.pagination_response import PaginationResponse
+from hatchet_sdk.clients.rest.models.v1_task_timing import V1TaskTiming
+
+
+class V1TaskTimingList(BaseModel):
+    """
+    V1TaskTimingList
+    """  # noqa: E501
+
+    pagination: PaginationResponse
+    rows: List[V1TaskTiming] = Field(description="The list of task timings")
+    __properties: ClassVar[List[str]] = ["pagination", "rows"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1TaskTimingList from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of pagination
+        if self.pagination:
+            _dict["pagination"] = self.pagination.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
+        _items = []
+        if self.rows:
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
+            _dict["rows"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1TaskTimingList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "pagination": (
+                    PaginationResponse.from_dict(obj["pagination"])
+                    if obj.get("pagination") is not None
+                    else None
+                ),
+                "rows": (
+                    [V1TaskTiming.from_dict(_item) for _item in obj["rows"]]
+                    if obj.get("rows") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

hatchet_sdk/hatchet.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from datetime import timedelta
 from typing import Any, Callable, Type, Union, cast, overload
 
 from hatchet_sdk import Context, DurableContext
@@ -21,8 +22,6 @@ from hatchet_sdk.logger import logger
 from hatchet_sdk.rate_limit import RateLimit
 from hatchet_sdk.runnables.standalone import Standalone
 from hatchet_sdk.runnables.types import (
-    DEFAULT_EXECUTION_TIMEOUT,
-    DEFAULT_SCHEDULE_TIMEOUT,
     ConcurrencyExpression,
     EmptyModel,
     R,
@@ -294,8 +293,8 @@ class Hatchet:
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
@@ -316,8 +315,8 @@ class Hatchet:
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
@@ -339,8 +338,8 @@ class Hatchet:
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | list[ConcurrencyExpression] | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
@@ -451,8 +450,8 @@ class Hatchet:
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
@@ -475,8 +474,8 @@ class Hatchet:
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},
@@ -498,8 +497,8 @@ class Hatchet:
         sticky: StickyStrategy | None = None,
         default_priority: int = 1,
         concurrency: ConcurrencyExpression | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         desired_worker_labels: dict[str, DesiredWorkerLabel] = {},

hatchet_sdk/runnables/task.py

@@ -1,10 +1,10 @@
+from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
     Awaitable,
     Callable,
     Generic,
-    TypeVar,
     Union,
     cast,
     get_type_hints,
@@ -18,8 +18,6 @@ from hatchet_sdk.contracts.v1.workflows_pb2 import (
     DesiredWorkerLabels,
 )
 from hatchet_sdk.runnables.types import (
-    DEFAULT_EXECUTION_TIMEOUT,
-    DEFAULT_SCHEDULE_TIMEOUT,
     ConcurrencyExpression,
     R,
     StepType,
@@ -43,18 +41,6 @@ if TYPE_CHECKING:
     from hatchet_sdk.runnables.workflow import Workflow
 
 
-T = TypeVar("T")
-
-
-def fall_back_to_default(value: T, default: T, fallback_value: T) -> T:
-    ## If the value is not the default, it's set
-    if value != default:
-        return value
-
-    ## Otherwise, it's unset, so return the fallback value
-    return fallback_value
-
-
 class Task(Generic[TWorkflowInput, R]):
     def __init__(
         self,
@@ -68,8 +54,8 @@ class Task(Generic[TWorkflowInput, R]):
         type: StepType,
         workflow: "Workflow[TWorkflowInput]",
         name: str,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
+        execution_timeout: Duration = timedelta(seconds=60),
+        schedule_timeout: Duration = timedelta(minutes=5),
         parents: "list[Task[TWorkflowInput, Any]]" = [],
         retries: int = 0,
         rate_limits: list[CreateTaskRateLimit] = [],
@@ -89,12 +75,8 @@ class Task(Generic[TWorkflowInput, R]):
         self.workflow = workflow
 
         self.type = type
-        self.execution_timeout = fall_back_to_default(
-            execution_timeout, DEFAULT_EXECUTION_TIMEOUT, DEFAULT_EXECUTION_TIMEOUT
-        )
-        self.schedule_timeout = fall_back_to_default(
-            schedule_timeout, DEFAULT_SCHEDULE_TIMEOUT, DEFAULT_SCHEDULE_TIMEOUT
-        )
+        self.execution_timeout = execution_timeout
+        self.schedule_timeout = schedule_timeout
         self.name = name
         self.parents = parents
         self.retries = retries

hatchet_sdk/runnables/types.py

@@ -1,9 +1,8 @@
 import asyncio
-from datetime import timedelta
 from enum import Enum
 from typing import Any, Awaitable, Callable, ParamSpec, Type, TypeGuard, TypeVar, Union
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from hatchet_sdk.context.context import Context, DurableContext
 from hatchet_sdk.contracts.v1.workflows_pb2 import Concurrency
@@ -16,11 +15,6 @@ R = TypeVar("R", bound=Union[ValidTaskReturnType, Awaitable[ValidTaskReturnType]
 P = ParamSpec("P")
 
 
-DEFAULT_EXECUTION_TIMEOUT = timedelta(seconds=60)
-DEFAULT_SCHEDULE_TIMEOUT = timedelta(minutes=5)
-DEFAULT_PRIORITY = 1
-
-
 class EmptyModel(BaseModel):
     model_config = ConfigDict(extra="allow", frozen=True)
 
@@ -65,9 +59,12 @@ TWorkflowInput = TypeVar("TWorkflowInput", bound=BaseModel)
 
 
 class TaskDefaults(BaseModel):
-    schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT
-    execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT
-    priority: StrictInt = Field(gt=0, lt=4, default=DEFAULT_PRIORITY)
+    schedule_timeout: Duration | None = None
+    execution_timeout: Duration | None = None
+    priority: int | None = Field(gt=0, lt=4, default=None)
+    retries: int | None = None
+    backoff_factor: float | None = None
+    backoff_max_seconds: int | None = None
 
 
 class WorkflowConfig(BaseModel):

hatchet_sdk/runnables/workflow.py

@@ -1,9 +1,9 @@
 import asyncio
 from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Any, Callable, Generic, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast
 
 from google.protobuf import timestamp_pb2
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 
 from hatchet_sdk.clients.admin import (
     ScheduleTriggerWorkflowOptions,
@@ -25,12 +25,11 @@ from hatchet_sdk.logger import logger
 from hatchet_sdk.rate_limit import RateLimit
 from hatchet_sdk.runnables.task import Task
 from hatchet_sdk.runnables.types import (
-    DEFAULT_EXECUTION_TIMEOUT,
-    DEFAULT_SCHEDULE_TIMEOUT,
     ConcurrencyExpression,
     EmptyModel,
     R,
     StepType,
+    TaskDefaults,
     TWorkflowInput,
     WorkflowConfig,
 )
@@ -45,6 +44,62 @@ if TYPE_CHECKING:
     from hatchet_sdk.runnables.standalone import Standalone
 
 
+T = TypeVar("T")
+
+
+def fall_back_to_default(value: T, param_default: T, fallback_value: T | None) -> T:
+    ## If the value is not the param default, it's set
+    if value != param_default:
+        return value
+
+    ## Otherwise, it's unset, so return the fallback value if it's set
+    if fallback_value is not None:
+        return fallback_value
+
+    ## Otherwise return the param value
+    return value
+
+
+class ComputedTaskParameters(BaseModel):
+    schedule_timeout: Duration
+    execution_timeout: Duration
+    retries: int
+    backoff_factor: float | None
+    backoff_max_seconds: int | None
+
+    task_defaults: TaskDefaults
+
+    @model_validator(mode="after")
+    def validate_params(self) -> "ComputedTaskParameters":
+        self.execution_timeout = fall_back_to_default(
+            value=self.execution_timeout,
+            param_default=timedelta(seconds=60),
+            fallback_value=self.task_defaults.execution_timeout,
+        )
+        self.schedule_timeout = fall_back_to_default(
+            value=self.schedule_timeout,
+            param_default=timedelta(minutes=5),
+            fallback_value=self.task_defaults.schedule_timeout,
+        )
+        self.backoff_factor = fall_back_to_default(
+            value=self.backoff_factor,
+            param_default=None,
+            fallback_value=self.task_defaults.backoff_factor,
+        )
+        self.backoff_max_seconds = fall_back_to_default(
+            value=self.backoff_max_seconds,
+            param_default=None,
+            fallback_value=self.task_defaults.backoff_max_seconds,
+        )
+        self.retries = fall_back_to_default(
+            value=self.retries,
+            param_default=0,
+            fallback_value=self.task_defaults.retries,
+        )
+
+        return self
+
+
 def transform_desired_worker_label(d: DesiredWorkerLabel) -> DesiredWorkerLabels:
     value = d.value
     return DesiredWorkerLabels(
@@ -530,8 +585,8 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     def task(
         self,
         name: str | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         parents: list[Task[TWorkflowInput, Any]] = [],
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
@@ -575,6 +630,15 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         :returns: A decorator which creates a `Task` object.
         """
 
+        computed_params = ComputedTaskParameters(
+            schedule_timeout=schedule_timeout,
+            execution_timeout=execution_timeout,
+            retries=retries,
+            backoff_factor=backoff_factor,
+            backoff_max_seconds=backoff_max_seconds,
+            task_defaults=self.config.task_defaults,
+        )
+
         def inner(
             func: Callable[[TWorkflowInput, Context], R]
         ) -> Task[TWorkflowInput, R]:
@@ -584,17 +648,17 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 workflow=self,
                 type=StepType.DEFAULT,
                 name=self._parse_task_name(name, func),
-                execution_timeout=execution_timeout,
-                schedule_timeout=schedule_timeout,
+                execution_timeout=computed_params.execution_timeout,
+                schedule_timeout=computed_params.schedule_timeout,
                 parents=parents,
-                retries=retries,
+                retries=computed_params.retries,
                 rate_limits=[r.to_proto() for r in rate_limits],
                 desired_worker_labels={
                     key: transform_desired_worker_label(d)
                     for key, d in desired_worker_labels.items()
                 },
-                backoff_factor=backoff_factor,
-                backoff_max_seconds=backoff_max_seconds,
+                backoff_factor=computed_params.backoff_factor,
+                backoff_max_seconds=computed_params.backoff_max_seconds,
                 concurrency=concurrency,
                 wait_for=wait_for,
                 skip_if=skip_if,
@@ -610,8 +674,8 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     def durable_task(
         self,
         name: str | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         parents: list[Task[TWorkflowInput, Any]] = [],
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
@@ -661,6 +725,15 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
         :returns: A decorator which creates a `Task` object.
         """
 
+        computed_params = ComputedTaskParameters(
+            schedule_timeout=schedule_timeout,
+            execution_timeout=execution_timeout,
+            retries=retries,
+            backoff_factor=backoff_factor,
+            backoff_max_seconds=backoff_max_seconds,
+            task_defaults=self.config.task_defaults,
+        )
+
         def inner(
             func: Callable[[TWorkflowInput, DurableContext], R]
         ) -> Task[TWorkflowInput, R]:
@@ -670,17 +743,17 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
                 workflow=self,
                 type=StepType.DEFAULT,
                 name=self._parse_task_name(name, func),
-                execution_timeout=execution_timeout,
-                schedule_timeout=schedule_timeout,
+                execution_timeout=computed_params.execution_timeout,
+                schedule_timeout=computed_params.schedule_timeout,
                 parents=parents,
-                retries=retries,
+                retries=computed_params.retries,
                 rate_limits=[r.to_proto() for r in rate_limits],
                 desired_worker_labels={
                     key: transform_desired_worker_label(d)
                     for key, d in desired_worker_labels.items()
                 },
-                backoff_factor=backoff_factor,
-                backoff_max_seconds=backoff_max_seconds,
+                backoff_factor=computed_params.backoff_factor,
+                backoff_max_seconds=computed_params.backoff_max_seconds,
                 concurrency=concurrency,
                 wait_for=wait_for,
                 skip_if=skip_if,
@@ -696,8 +769,8 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     def on_failure_task(
         self,
         name: str | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         backoff_factor: float | None = None,
@@ -756,8 +829,8 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
     def on_success_task(
         self,
         name: str | None = None,
-        schedule_timeout: Duration = DEFAULT_SCHEDULE_TIMEOUT,
-        execution_timeout: Duration = DEFAULT_EXECUTION_TIMEOUT,
+        schedule_timeout: Duration = timedelta(minutes=5),
+        execution_timeout: Duration = timedelta(seconds=60),
         retries: int = 0,
         rate_limits: list[RateLimit] = [],
         backoff_factor: float | None = None,

{hatchet_sdk-1.7.0.dist-info → hatchet_sdk-1.8.0.dist-info}/METADATA

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

{hatchet_sdk-1.7.0.dist-info → hatchet_sdk-1.8.0.dist-info}/RECORD

@@ -9,7 +9,7 @@ hatchet_sdk/clients/listeners/durable_event_listener.py,sha256=jpqnbZsuouWk3XaOI
 hatchet_sdk/clients/listeners/pooled_listener.py,sha256=1rodfIeqmHRF-u-PB6cBJbOU8NrvToLTyGigJMydpGo,8496
 hatchet_sdk/clients/listeners/run_event_listener.py,sha256=rIjBLRF7d7FBoEq7RKbmbOA84lX_hHSU26trwnthqV8,10230
 hatchet_sdk/clients/listeners/workflow_listener.py,sha256=EhBZZnHiidDLvAc4r54Re_LJXVypinbgTE9qKBybxj8,2054
-hatchet_sdk/clients/rest/__init__.py,sha256=Bee4HPFiMGDHx5xbHkxxVbLBz_mDgSZUqh-nIhvsD1k,16511
+hatchet_sdk/clients/rest/__init__.py,sha256=5lTVCDrwielWr5A_dnCL4xNiVWnyS1zLXLNxINM_p4Y,16664
 hatchet_sdk/clients/rest/api/__init__.py,sha256=XWlkH9iwpQvJHDqKe7kWl3MUzcTOaH-JiFZbki_fg_U,1200
 hatchet_sdk/clients/rest/api/api_token_api.py,sha256=xzqMH_-wajBA0qLLs5Ta7tYg4FOLq0NjATyhZ1SV9jo,33433
 hatchet_sdk/clients/rest/api/default_api.py,sha256=Y0jEhatVpdIX_W2MCt_n40K6iKvVegDB70qxexkeZDI,88677
@@ -22,18 +22,18 @@ hatchet_sdk/clients/rest/api/rate_limits_api.py,sha256=e3CIX35R8SkV8LrgLMPCAy6Kz
 hatchet_sdk/clients/rest/api/slack_api.py,sha256=0xIUw3_1_3hSTn2yw7fLRO5yb38nYLu5aLM7IE2pnwk,21894
 hatchet_sdk/clients/rest/api/sns_api.py,sha256=1LfhnZEA450uHwtZCoM_wycOeH4UGwfNP1pw4RWSe08,33641
 hatchet_sdk/clients/rest/api/step_run_api.py,sha256=rqP4UIJSkw8DwbDnlEgupBDWUL0jlVH_Rm7bNGMUoG8,84505
-hatchet_sdk/clients/rest/api/task_api.py,sha256=x2m8VTvpYJuWZ58KWS4EnKItlxJgP0Ch8_89t2yKlF8,86367
+hatchet_sdk/clients/rest/api/task_api.py,sha256=rpppMT70gverBsDYaI9owYUwaDVicxIZRqsCBqPfVi8,87464
 hatchet_sdk/clients/rest/api/tenant_api.py,sha256=LYUdJSsg-O-Y_7cuCDdtDHP5P0BQ9ch8RFLQKIiIreQ,177493
 hatchet_sdk/clients/rest/api/user_api.py,sha256=NYuEKLeBjXO4q8gyYq1thtbuRm9m3g0R6-q6LIfv83U,115780
 hatchet_sdk/clients/rest/api/worker_api.py,sha256=56jRXsyK7SDENly2b019EO80d8xOHU4bZnmOmjKY1iQ,33049
 hatchet_sdk/clients/rest/api/workflow_api.py,sha256=rpPXy5xZDZWo1GXQGLapTC3A5M_spk1zoK_vu_J7SVA,251652
 hatchet_sdk/clients/rest/api/workflow_run_api.py,sha256=Jvge80z6DhlqL9OuLzUC49OtojeiCuagrMbNBThMYI4,78120
-hatchet_sdk/clients/rest/api/workflow_runs_api.py,sha256=_zFmx0DTztKK2xa5BKBYhYqveIbNBc4g9DkNPIJeUxQ,70192
-hatchet_sdk/clients/rest/api_client.py,sha256=g1ECXTfdPHyM2yZuX4FZWZwvl5FZ9dEok0EKyeqLkRA,26813
+hatchet_sdk/clients/rest/api/workflow_runs_api.py,sha256=NiDZXDUM7VapgjQ68z8MWPqZKTfz7rPBvPwGG5AJyZg,81997
+hatchet_sdk/clients/rest/api_client.py,sha256=25vNKzpKVhvrGrU8T2YBLbz0Y7K0pKZwiLXF3Oc7tt0,27435
 hatchet_sdk/clients/rest/api_response.py,sha256=rSuCVGY-HE8X_WwteQP5wyANIuS-L5AmtZEUOwTicak,641
 hatchet_sdk/clients/rest/configuration.py,sha256=ijGxGorVe8OEikJruwJ0hPk1Rc0OAKOqeUrfcoEiYH8,19333
 hatchet_sdk/clients/rest/exceptions.py,sha256=5PTEjyGxLeGP8U_qqc79QzR-sN7SOhzBwknSUC-BU4c,6365
-hatchet_sdk/clients/rest/models/__init__.py,sha256=BAwgrsAKYGiS9A3ZtK2ROF9xjiKa3qA7Z_NqBOGgzXI,14931
+hatchet_sdk/clients/rest/models/__init__.py,sha256=5Tse5Ljxu7tONV7ePuf9aFWM2oc1ehBaH90BiiAgdYA,15084
 hatchet_sdk/clients/rest/models/accept_invite_request.py,sha256=_otOis3SuTHl0F_hhYD-rYqgyxCXRn83CK_eU9oMdn4,2427
 hatchet_sdk/clients/rest/models/api_error.py,sha256=KodK1_cc28CgYGvX1WhIhTN0pAAkgq8PJXReIrMnqBA,3068
 hatchet_sdk/clients/rest/models/api_errors.py,sha256=RNmnWn1GWlG9xTvpvrTmKq-Pr70x9mcJ4-dNFBemxa8,2917
@@ -165,8 +165,10 @@ hatchet_sdk/clients/rest/models/v1_task_point_metrics.py,sha256=shKqLFLgNAKua865
 hatchet_sdk/clients/rest/models/v1_task_run_metric.py,sha256=8trEgJ_7AHAmUQi2Qty-v5XVjgN3g7VZ6gzMTjeZ1tY,2504
 hatchet_sdk/clients/rest/models/v1_task_run_status.py,sha256=tjipWHHNx7g4lUZBdu_DDZwEqSpxPKv06YiE2Q17cXo,753
 hatchet_sdk/clients/rest/models/v1_task_status.py,sha256=4Hqczjth228k8Y23vIaxAIzTpLaS9mh9I0PrTjY8JRY,742
-hatchet_sdk/clients/rest/models/v1_task_summary.py,sha256=GbHZN4fCkysTgfZKjaaWS-8bAFwgX7l5u4hAKLhDlw4,8371
+hatchet_sdk/clients/rest/models/v1_task_summary.py,sha256=Unbtm9n-NexT37F0S0af2mYxYtWhcbuYDlk4EYh15c0,8330
 hatchet_sdk/clients/rest/models/v1_task_summary_list.py,sha256=0m-xf_lY9BwwbLky9i6fkTYUwh2K9mADHVZoRyF66o4,3510
+hatchet_sdk/clients/rest/models/v1_task_timing.py,sha256=cYO73DfWGPzxvM7hUF-CXiTHfKVsGtgQalcVKoveBwo,5299
+hatchet_sdk/clients/rest/models/v1_task_timing_list.py,sha256=1LFoKqFn11EJ_t7ZeWUFldWOWfG09tN_wTZu3a8e_SM,3509
 hatchet_sdk/clients/rest/models/v1_trigger_workflow_run_request.py,sha256=P-dC3O7dPr6mGJ2UZYcl3lSQoxKcX-GlYOiWkmNRMj0,3080
 hatchet_sdk/clients/rest/models/v1_workflow_run.py,sha256=0kgHJ35XjXgNfaJfb1p0KLS1Jw6VAMeMYSdts8EvuYc,5895
 hatchet_sdk/clients/rest/models/v1_workflow_run_details.py,sha256=vMnc50mT-tjfFlg2BJ58s2HhFvqvuGJaPGYAlTrLVI4,5040
@@ -250,7 +252,7 @@ hatchet_sdk/features/runs.py,sha256=9kmn2AM1XVFZS9P_lR-hh6SXwW42Kh73l0WUBl5VJh8,
 hatchet_sdk/features/scheduled.py,sha256=1kNR8AxN1UlabNroU9TtVbptZEXfqTVE25Gxmh2lABs,8928
 hatchet_sdk/features/workers.py,sha256=vD6j7GCttu0fm23_XmBMdE0IuX4mUbL0adgMoC8Sk_E,2571
 hatchet_sdk/features/workflows.py,sha256=PFJsGXTHVfdDBDQ9WcQXcAzr7u-dN7vUpwbZ9fH0ZD8,3976
-hatchet_sdk/hatchet.py,sha256=kIRcvHiLgyOc1OY1uytNatUZ8qaYA4beqoKEiqFcRpE,21873
+hatchet_sdk/hatchet.py,sha256=HRa__owQMeSRhtXzEfObap3ZKxUeNq2FJKOZEUVZ_CI,21795
 hatchet_sdk/labels.py,sha256=nATgxWE3lFxRTnfISEpoIRLGbMfAZsHF4lZTuG4Mfic,182
 hatchet_sdk/logger.py,sha256=5uOr52T4mImSQm1QvWT8HvZFK5WfPNh3Y1cBQZRFgUQ,333
 hatchet_sdk/metadata.py,sha256=XkRbhnghJJGCdVvF-uzyGBcNaTqpeQ3uiQvNNP1wyBc,107
@@ -259,9 +261,9 @@ hatchet_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatchet_sdk/rate_limit.py,sha256=TwbCuggiZaWpYuo4mjVLlE-z1OfQ2mRBiVvCSaG3lv4,3919
 hatchet_sdk/runnables/contextvars.py,sha256=6MDocAMmlyiRW37oQ1jyx10tAlJs-xgDjR3xPoPz05g,426
 hatchet_sdk/runnables/standalone.py,sha256=pCAIS40q9ltkK7K97ff79MzE73_k22ymZdrLdFdFwD8,15233
-hatchet_sdk/runnables/task.py,sha256=nZPclBbNaYRMlCLOYi91YU503MiTcGSp92Unh3_nKvs,7533
-hatchet_sdk/runnables/types.py,sha256=hF_8kcSWIVXgYspp67RwSfi-CFZJFTbb8mL8BHR8tG8,4889
-hatchet_sdk/runnables/workflow.py,sha256=blkUagpVa-zqEpXYk_MXKz3c5uhKPse_0o2L_48nGZo,37221
+hatchet_sdk/runnables/task.py,sha256=5VOgi413eH8Gz9_XBxFTfbfLITTpPJYwRB2ZXshysW8,7014
+hatchet_sdk/runnables/types.py,sha256=OBhqa6rvEaY4ypKtUpKHHyQxOXKYvxao_-Hknu5jVns,4802
+hatchet_sdk/runnables/workflow.py,sha256=Ucjguf3SxyJzYe7R427U76iUOLDoHQMzwOQ7g9xYuQA,39765
 hatchet_sdk/token.py,sha256=KjIiInwG5Kqd_FO4BSW1x_5Uc7PFbnzIVJqr50-ZldE,779
 hatchet_sdk/utils/backoff.py,sha256=6B5Rb5nLKw_TqqgpJMYjIBV1PTTtbOMRZCveisVhg_I,353
 hatchet_sdk/utils/proto_enums.py,sha256=0UybwE3s7TcqmzoQSO8YnhgAKOS8WZXsyPchB8-eksw,1247
@@ -506,7 +508,7 @@ hatchet_sdk/worker/runner/runner.py,sha256=z8ri-viK_avAfF6zgbVNBc-rztFDbxSwng3RH
 hatchet_sdk/worker/runner/utils/capture_logs.py,sha256=nHRPSiDBqzhObM7i2X7t03OupVFnE7kQBdR2Ckgg-2w,2709
 hatchet_sdk/worker/worker.py,sha256=SfUeYYGfPDVa7Hr1Tdgrzn_A0T-e_apIzW26BhsiB70,16101
 hatchet_sdk/workflow_run.py,sha256=ZwH0HLFGFVXz6jbiqSv4w0Om2XuR52Tzzw6LH4y65jQ,2765
-hatchet_sdk-1.7.0.dist-info/METADATA,sha256=-bxsuAlZWUGADJ4lSl2TaRvobNsFujBDtHSik2_JYog,3635
-hatchet_sdk-1.7.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-hatchet_sdk-1.7.0.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
-hatchet_sdk-1.7.0.dist-info/RECORD,,
+hatchet_sdk-1.8.0.dist-info/METADATA,sha256=MWSM2jbWn8RIm0J-On_FJy4paoq249kv1NvozdH9Y3M,3635
+hatchet_sdk-1.8.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+hatchet_sdk-1.8.0.dist-info/entry_points.txt,sha256=Un_76pcLse-ZGBlwebhQpnTPyQrripeHW8J7qmEpGOk,1400
+hatchet_sdk-1.8.0.dist-info/RECORD,,