hatchet-sdk 1.7.0__tar.gz → 1.8.0__tar.gz

{hatchet_sdk-1.7.0 → hatchet_sdk-1.8.0}/PKG-INFO

@@ -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 → hatchet_sdk-1.8.0}/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-1.7.0 → hatchet_sdk-1.8.0}/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-1.7.0 → hatchet_sdk-1.8.0}/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-1.7.0 → hatchet_sdk-1.8.0}/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-1.7.0 → hatchet_sdk-1.8.0}/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-1.7.0 → hatchet_sdk-1.8.0}/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-1.8.0/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