hatchet-sdk 0.46.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

hatchet_sdk/clients/rest/api_client.py

@@ -513,7 +513,7 @@ class ApiClient:
             if k in collection_formats:
                 collection_format = collection_formats[k]
                 if collection_format == "multi":
-                    new_params.extend((k, str(value)) for value in v)
+                    new_params.extend((k, quote(str(value))) for value in v)
                 else:
                     if collection_format == "ssv":
                         delimiter = " "

hatchet_sdk/clients/rest/configuration.py

@@ -17,7 +17,7 @@ import http.client as httplib
 import logging
 import sys
 from logging import FileHandler
-from typing import Any, ClassVar, Dict, List, Literal, Optional, TypedDict
+from typing import Any, ClassVar, Dict, List, Literal, Optional, TypedDict, Union
 
 import urllib3
 from typing_extensions import NotRequired, Self
@@ -167,6 +167,8 @@ class Configuration:
         :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
           in PEM format.
         :param retries: Number of retries for API requests.
+        :param ca_cert_data: verify the peer using concatenated CA certificate data
+          in PEM (str) or DER (bytes) format.
 
         :Example:
 
@@ -207,6 +209,7 @@ class Configuration:
         ignore_operation_servers: bool = False,
         ssl_ca_cert: Optional[str] = None,
         retries: Optional[int] = None,
+        ca_cert_data: Optional[Union[str, bytes]] = None,
         *,
         debug: Optional[bool] = None,
     ) -> None:
@@ -283,6 +286,10 @@ class Configuration:
         self.ssl_ca_cert = ssl_ca_cert
         """Set this to customize the certificate file to verify the peer.
         """
+        self.ca_cert_data = ca_cert_data
+        """Set this to verify the peer using PEM (str) or DER (bytes)
+           certificate data.
+        """
         self.cert_file = None
         """client certificate file
         """

hatchet_sdk/clients/rest/exceptions.py

@@ -153,6 +153,15 @@ class ApiException(OpenApiException):
         if http_resp.status == 404:
             raise NotFoundException(http_resp=http_resp, body=body, data=data)
 
+        # Added new conditions for 409 and 422
+        if http_resp.status == 409:
+            raise ConflictException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 422:
+            raise UnprocessableEntityException(
+                http_resp=http_resp, body=body, data=data
+            )
+
         if 500 <= http_resp.status <= 599:
             raise ServiceException(http_resp=http_resp, body=body, data=data)
         raise ApiException(http_resp=http_resp, body=body, data=data)
@@ -189,6 +198,18 @@ class ServiceException(ApiException):
     pass
 
 
+class ConflictException(ApiException):
+    """Exception for HTTP 409 Conflict."""
+
+    pass
+
+
+class UnprocessableEntityException(ApiException):
+    """Exception for HTTP 422 Unprocessable Entity."""
+
+    pass
+
+
 def render_path(path_to_item):
     """Returns a string representation of a path"""
     result = ""

hatchet_sdk/clients/rest/models/__init__.py

@@ -171,6 +171,7 @@ from hatchet_sdk.clients.rest.models.tenant_resource_policy import TenantResourc
 from hatchet_sdk.clients.rest.models.tenant_step_run_queue_metrics import (
     TenantStepRunQueueMetrics,
 )
+from hatchet_sdk.clients.rest.models.tenant_version import TenantVersion
 from hatchet_sdk.clients.rest.models.trigger_workflow_run_request import (
     TriggerWorkflowRunRequest,
 )
@@ -192,6 +193,24 @@ from hatchet_sdk.clients.rest.models.user_tenant_memberships_list import (
     UserTenantMembershipsList,
 )
 from hatchet_sdk.clients.rest.models.user_tenant_public import UserTenantPublic
+from hatchet_sdk.clients.rest.models.v1_cancel_task_request import V1CancelTaskRequest
+from hatchet_sdk.clients.rest.models.v1_dag_children import V1DagChildren
+from hatchet_sdk.clients.rest.models.v1_replay_task_request import V1ReplayTaskRequest
+from hatchet_sdk.clients.rest.models.v1_task import V1Task
+from hatchet_sdk.clients.rest.models.v1_task_event import V1TaskEvent
+from hatchet_sdk.clients.rest.models.v1_task_event_list import V1TaskEventList
+from hatchet_sdk.clients.rest.models.v1_task_event_type import V1TaskEventType
+from hatchet_sdk.clients.rest.models.v1_task_filter import V1TaskFilter
+from hatchet_sdk.clients.rest.models.v1_task_point_metric import V1TaskPointMetric
+from hatchet_sdk.clients.rest.models.v1_task_point_metrics import V1TaskPointMetrics
+from hatchet_sdk.clients.rest.models.v1_task_run_metric import V1TaskRunMetric
+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_workflow_run import V1WorkflowRun
+from hatchet_sdk.clients.rest.models.v1_workflow_run_details import V1WorkflowRunDetails
+from hatchet_sdk.clients.rest.models.v1_workflow_type import V1WorkflowType
 from hatchet_sdk.clients.rest.models.webhook_worker import WebhookWorker
 from hatchet_sdk.clients.rest.models.webhook_worker_create_request import (
     WebhookWorkerCreateRequest,
@@ -230,6 +249,9 @@ from hatchet_sdk.clients.rest.models.workflow_run_order_by_field import (
     WorkflowRunOrderByField,
 )
 from hatchet_sdk.clients.rest.models.workflow_run_shape import WorkflowRunShape
+from hatchet_sdk.clients.rest.models.workflow_run_shape_item_for_workflow_run_details import (
+    WorkflowRunShapeItemForWorkflowRunDetails,
+)
 from hatchet_sdk.clients.rest.models.workflow_run_status import WorkflowRunStatus
 from hatchet_sdk.clients.rest.models.workflow_run_triggered_by import (
     WorkflowRunTriggeredBy,

hatchet_sdk/clients/rest/models/tenant.py

@@ -23,6 +23,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing_extensions import Self
 
 from hatchet_sdk.clients.rest.models.api_resource_meta import APIResourceMeta
+from hatchet_sdk.clients.rest.models.tenant_version import TenantVersion
 
 
 class Tenant(BaseModel):
@@ -43,12 +44,14 @@ class Tenant(BaseModel):
         description="Whether to alert tenant members.",
         alias="alertMemberEmails",
     )
+    version: TenantVersion = Field(description="The version of the tenant.")
     __properties: ClassVar[List[str]] = [
         "metadata",
         "name",
         "slug",
         "analyticsOptOut",
         "alertMemberEmails",
+        "version",
     ]
 
     model_config = ConfigDict(
@@ -113,6 +116,7 @@ class Tenant(BaseModel):
                 "slug": obj.get("slug"),
                 "analyticsOptOut": obj.get("analyticsOptOut"),
                 "alertMemberEmails": obj.get("alertMemberEmails"),
+                "version": obj.get("version"),
             }
         )
         return _obj

hatchet_sdk/clients/rest/models/tenant_version.py

@@ -0,0 +1,37 @@
+# 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
+from enum import Enum
+
+from typing_extensions import Self
+
+
+class TenantVersion(str, Enum):
+    """
+    TenantVersion
+    """
+
+    """
+    allowed enum values
+    """
+    V0 = "V0"
+    V1 = "V1"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of TenantVersion from a JSON string"""
+        return cls(json.loads(json_str))

hatchet_sdk/clients/rest/models/update_tenant_request.py

@@ -22,6 +22,8 @@ from typing import Any, ClassVar, Dict, List, Optional, Set
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing_extensions import Self
 
+from hatchet_sdk.clients.rest.models.tenant_version import TenantVersion
+
 
 class UpdateTenantRequest(BaseModel):
     """
@@ -61,6 +63,9 @@ class UpdateTenantRequest(BaseModel):
         description="The max frequency at which to alert.",
         alias="maxAlertingFrequency",
     )
+    version: Optional[TenantVersion] = Field(
+        default=None, description="The version of the tenant."
+    )
     __properties: ClassVar[List[str]] = [
         "name",
         "analyticsOptOut",
@@ -69,6 +74,7 @@ class UpdateTenantRequest(BaseModel):
         "enableExpiringTokenAlerts",
         "enableTenantResourceLimitAlerts",
         "maxAlertingFrequency",
+        "version",
     ]
 
     model_config = ConfigDict(
@@ -132,6 +138,7 @@ class UpdateTenantRequest(BaseModel):
                     "enableTenantResourceLimitAlerts"
                 ),
                 "maxAlertingFrequency": obj.get("maxAlertingFrequency"),
+                "version": obj.get("version"),
             }
         )
         return _obj

hatchet_sdk/clients/rest/models/v1_cancel_task_request.py

@@ -0,0 +1,104 @@
+# 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 Annotated, Self
+
+from hatchet_sdk.clients.rest.models.v1_task_filter import V1TaskFilter
+
+
+class V1CancelTaskRequest(BaseModel):
+    """
+    V1CancelTaskRequest
+    """  # noqa: E501
+
+    external_ids: Optional[
+        List[Annotated[str, Field(min_length=36, strict=True, max_length=36)]]
+    ] = Field(
+        default=None,
+        description="A list of external IDs, which can refer to either task or workflow run external IDs",
+        alias="externalIds",
+    )
+    filter: Optional[V1TaskFilter] = None
+    __properties: ClassVar[List[str]] = ["externalIds", "filter"]
+
+    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 V1CancelTaskRequest 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 filter
+        if self.filter:
+            _dict["filter"] = self.filter.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1CancelTaskRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "externalIds": obj.get("externalIds"),
+                "filter": (
+                    V1TaskFilter.from_dict(obj["filter"])
+                    if obj.get("filter") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

hatchet_sdk/clients/rest/models/v1_dag_children.py

@@ -0,0 +1,102 @@
+# 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, StrictStr
+from typing_extensions import Self
+
+from hatchet_sdk.clients.rest.models.v1_task_summary import V1TaskSummary
+
+
+class V1DagChildren(BaseModel):
+    """
+    V1DagChildren
+    """  # noqa: E501
+
+    dag_id: Optional[StrictStr] = Field(default=None, alias="dagId")
+    children: Optional[List[V1TaskSummary]] = None
+    __properties: ClassVar[List[str]] = ["dagId", "children"]
+
+    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 V1DagChildren 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 each item in children (list)
+        _items = []
+        if self.children:
+            for _item_children in self.children:
+                if _item_children:
+                    _items.append(_item_children.to_dict())
+            _dict["children"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1DagChildren from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "dagId": obj.get("dagId"),
+                "children": (
+                    [V1TaskSummary.from_dict(_item) for _item in obj["children"]]
+                    if obj.get("children") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

hatchet_sdk/clients/rest/models/v1_replay_task_request.py

@@ -0,0 +1,104 @@
+# 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 Annotated, Self
+
+from hatchet_sdk.clients.rest.models.v1_task_filter import V1TaskFilter
+
+
+class V1ReplayTaskRequest(BaseModel):
+    """
+    V1ReplayTaskRequest
+    """  # noqa: E501
+
+    external_ids: Optional[
+        List[Annotated[str, Field(min_length=36, strict=True, max_length=36)]]
+    ] = Field(
+        default=None,
+        description="A list of external IDs, which can refer to either task or workflow run external IDs",
+        alias="externalIds",
+    )
+    filter: Optional[V1TaskFilter] = None
+    __properties: ClassVar[List[str]] = ["externalIds", "filter"]
+
+    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 V1ReplayTaskRequest 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 filter
+        if self.filter:
+            _dict["filter"] = self.filter.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1ReplayTaskRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "externalIds": obj.get("externalIds"),
+                "filter": (
+                    V1TaskFilter.from_dict(obj["filter"])
+                    if obj.get("filter") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj