hatchet-sdk 0.40.0a9__py3-none-any.whl → 0.42.0__py3-none-any.whl

hatchet_sdk/clients/{cloud_rest/models/github_app_list_installations200_response_rows_inner.py → rest/models/cron_workflows.py}

@@ -19,30 +19,58 @@ import pprint
 import re  # noqa: F401
 from typing import Any, ClassVar, Dict, List, Optional, Set
 
-from pydantic import BaseModel, ConfigDict, StrictStr
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictStr,
+    field_validator,
+)
 from typing_extensions import Self
 
-from hatchet_sdk.clients.cloud_rest.models.github_app_list_installations200_response_rows_inner_metadata import (
-    GithubAppListInstallations200ResponseRowsInnerMetadata,
-)
+from hatchet_sdk.clients.rest.models.api_resource_meta import APIResourceMeta
 
 
-class GithubAppListInstallations200ResponseRowsInner(BaseModel):
+class CronWorkflows(BaseModel):
     """
-    GithubAppListInstallations200ResponseRowsInner
+    CronWorkflows
     """  # noqa: E501
 
-    metadata: GithubAppListInstallations200ResponseRowsInnerMetadata
-    installation_settings_url: StrictStr
-    account_name: StrictStr
-    account_avatar_url: StrictStr
+    metadata: APIResourceMeta
+    tenant_id: StrictStr = Field(alias="tenantId")
+    workflow_version_id: StrictStr = Field(alias="workflowVersionId")
+    workflow_id: StrictStr = Field(alias="workflowId")
+    workflow_name: StrictStr = Field(alias="workflowName")
+    cron: StrictStr
+    name: Optional[StrictStr] = None
+    input: Optional[Dict[str, Any]] = None
+    additional_metadata: Optional[Dict[str, Any]] = Field(
+        default=None, alias="additionalMetadata"
+    )
+    enabled: StrictBool
+    method: StrictStr
     __properties: ClassVar[List[str]] = [
         "metadata",
-        "installation_settings_url",
-        "account_name",
-        "account_avatar_url",
+        "tenantId",
+        "workflowVersionId",
+        "workflowId",
+        "workflowName",
+        "cron",
+        "name",
+        "input",
+        "additionalMetadata",
+        "enabled",
+        "method",
     ]
 
+    @field_validator("method")
+    def method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["DEFAULT", "API"]):
+            raise ValueError("must be one of enum values ('DEFAULT', 'API')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,
@@ -60,7 +88,7 @@ class GithubAppListInstallations200ResponseRowsInner(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of GithubAppListInstallations200ResponseRowsInner from a JSON string"""
+        """Create an instance of CronWorkflows from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -87,7 +115,7 @@ class GithubAppListInstallations200ResponseRowsInner(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of GithubAppListInstallations200ResponseRowsInner from a dict"""
+        """Create an instance of CronWorkflows from a dict"""
         if obj is None:
             return None
 
@@ -97,15 +125,20 @@ class GithubAppListInstallations200ResponseRowsInner(BaseModel):
         _obj = cls.model_validate(
             {
                 "metadata": (
-                    GithubAppListInstallations200ResponseRowsInnerMetadata.from_dict(
-                        obj["metadata"]
-                    )
+                    APIResourceMeta.from_dict(obj["metadata"])
                     if obj.get("metadata") is not None
                     else None
                 ),
-                "installation_settings_url": obj.get("installation_settings_url"),
-                "account_name": obj.get("account_name"),
-                "account_avatar_url": obj.get("account_avatar_url"),
+                "tenantId": obj.get("tenantId"),
+                "workflowVersionId": obj.get("workflowVersionId"),
+                "workflowId": obj.get("workflowId"),
+                "workflowName": obj.get("workflowName"),
+                "cron": obj.get("cron"),
+                "name": obj.get("name"),
+                "input": obj.get("input"),
+                "additionalMetadata": obj.get("additionalMetadata"),
+                "enabled": obj.get("enabled"),
+                "method": obj.get("method"),
             }
         )
         return _obj

hatchet_sdk/clients/{cloud_rest/models/log_list200_response.py → rest/models/cron_workflows_list.py}

@@ -22,21 +22,17 @@ from typing import Any, ClassVar, Dict, List, Optional, Set
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import Self
 
-from hatchet_sdk.clients.cloud_rest.models.github_app_list_installations200_response_pagination import (
-    GithubAppListInstallations200ResponsePagination,
-)
-from hatchet_sdk.clients.cloud_rest.models.log_list200_response_rows_inner import (
-    LogList200ResponseRowsInner,
-)
+from hatchet_sdk.clients.rest.models.cron_workflows import CronWorkflows
+from hatchet_sdk.clients.rest.models.pagination_response import PaginationResponse
 
 
-class LogList200Response(BaseModel):
+class CronWorkflowsList(BaseModel):
     """
-    LogList200Response
+    CronWorkflowsList
     """  # noqa: E501
 
-    rows: Optional[List[LogList200ResponseRowsInner]] = None
-    pagination: Optional[GithubAppListInstallations200ResponsePagination] = None
+    rows: Optional[List[CronWorkflows]] = None
+    pagination: Optional[PaginationResponse] = None
     __properties: ClassVar[List[str]] = ["rows", "pagination"]
 
     model_config = ConfigDict(
@@ -56,7 +52,7 @@ class LogList200Response(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of LogList200Response from a JSON string"""
+        """Create an instance of CronWorkflowsList from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -79,9 +75,9 @@ class LogList200Response(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         # override the default output from pydantic by calling `to_dict()` of pagination
         if self.pagination:
@@ -90,7 +86,7 @@ class LogList200Response(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of LogList200Response from a dict"""
+        """Create an instance of CronWorkflowsList from a dict"""
         if obj is None:
             return None
 
@@ -100,17 +96,12 @@ class LogList200Response(BaseModel):
         _obj = cls.model_validate(
             {
                 "rows": (
-                    [
-                        LogList200ResponseRowsInner.from_dict(_item)
-                        for _item in obj["rows"]
-                    ]
+                    [CronWorkflows.from_dict(_item) for _item in obj["rows"]]
                     if obj.get("rows") is not None
                     else None
                 ),
                 "pagination": (
-                    GithubAppListInstallations200ResponsePagination.from_dict(
-                        obj["pagination"]
-                    )
+                    PaginationResponse.from_dict(obj["pagination"])
                     if obj.get("pagination") is not None
                     else None
                 ),

hatchet_sdk/clients/rest/models/cron_workflows_order_by_field.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 CronWorkflowsOrderByField(str, Enum):
+    """
+    CronWorkflowsOrderByField
+    """
+
+    """
+    allowed enum values
+    """
+    NAME = "name"
+    CREATEDAT = "createdAt"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of CronWorkflowsOrderByField from a JSON string"""
+        return cls(json.loads(json_str))

hatchet_sdk/clients/rest/models/event_list.py

@@ -78,9 +78,9 @@ class EventList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/get_step_run_diff_response.py

@@ -73,9 +73,9 @@ class GetStepRunDiffResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in diffs (list)
         _items = []
         if self.diffs:
-            for _item in self.diffs:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_diffs in self.diffs:
+                if _item_diffs:
+                    _items.append(_item_diffs.to_dict())
             _dict["diffs"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/job.py

@@ -95,9 +95,9 @@ class Job(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in steps (list)
         _items = []
         if self.steps:
-            for _item in self.steps:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_steps in self.steps:
+                if _item_steps:
+                    _items.append(_item_steps.to_dict())
             _dict["steps"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/job_run.py

@@ -117,9 +117,9 @@ class JobRun(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in step_runs (list)
         _items = []
         if self.step_runs:
-            for _item in self.step_runs:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_step_runs in self.step_runs:
+                if _item_step_runs:
+                    _items.append(_item_step_runs.to_dict())
             _dict["stepRuns"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/list_api_tokens_response.py

@@ -78,9 +78,9 @@ class ListAPITokensResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/list_pull_requests_response.py

@@ -73,9 +73,9 @@ class ListPullRequestsResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in pull_requests (list)
         _items = []
         if self.pull_requests:
-            for _item in self.pull_requests:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_pull_requests in self.pull_requests:
+                if _item_pull_requests:
+                    _items.append(_item_pull_requests.to_dict())
             _dict["pullRequests"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/list_slack_webhooks.py

@@ -78,9 +78,9 @@ class ListSlackWebhooks(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/list_sns_integrations.py

@@ -78,9 +78,9 @@ class ListSNSIntegrations(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/log_line_list.py

@@ -78,9 +78,9 @@ class LogLineList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/rate_limit_list.py

@@ -78,9 +78,9 @@ class RateLimitList(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in rows (list)
         _items = []
         if self.rows:
-            for _item in self.rows:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_rows in self.rows:
+                if _item_rows:
+                    _items.append(_item_rows.to_dict())
             _dict["rows"] = _items
         return _dict
 

hatchet_sdk/clients/rest/models/replay_workflow_runs_response.py

@@ -73,9 +73,9 @@ class ReplayWorkflowRunsResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in workflow_runs (list)
         _items = []
         if self.workflow_runs:
-            for _item in self.workflow_runs:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_workflow_runs in self.workflow_runs:
+                if _item_workflow_runs:
+                    _items.append(_item_workflow_runs.to_dict())
             _dict["workflowRuns"] = _items
         return _dict
 

hatchet_sdk/clients/{cloud_rest/models/log_list200_response_rows_inner.py → rest/models/schedule_workflow_run_request.py}

@@ -20,19 +20,19 @@ import re  # noqa: F401
 from datetime import datetime
 from typing import Any, ClassVar, Dict, List, Optional, Set
 
-from pydantic import BaseModel, ConfigDict, StrictStr
+from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Self
 
 
-class LogList200ResponseRowsInner(BaseModel):
+class ScheduleWorkflowRunRequest(BaseModel):
     """
-    LogList200ResponseRowsInner
+    ScheduleWorkflowRunRequest
     """  # noqa: E501
 
-    timestamp: datetime
-    instance: StrictStr
-    line: StrictStr
-    __properties: ClassVar[List[str]] = ["timestamp", "instance", "line"]
+    input: Dict[str, Any]
+    additional_metadata: Dict[str, Any] = Field(alias="additionalMetadata")
+    trigger_at: datetime = Field(alias="triggerAt")
+    __properties: ClassVar[List[str]] = ["input", "additionalMetadata", "triggerAt"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -51,7 +51,7 @@ class LogList200ResponseRowsInner(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of LogList200ResponseRowsInner from a JSON string"""
+        """Create an instance of ScheduleWorkflowRunRequest from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -75,7 +75,7 @@ class LogList200ResponseRowsInner(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of LogList200ResponseRowsInner from a dict"""
+        """Create an instance of ScheduleWorkflowRunRequest from a dict"""
         if obj is None:
             return None
 
@@ -84,9 +84,9 @@ class LogList200ResponseRowsInner(BaseModel):
 
         _obj = cls.model_validate(
             {
-                "timestamp": obj.get("timestamp"),
-                "instance": obj.get("instance"),
-                "line": obj.get("line"),
+                "input": obj.get("input"),
+                "additionalMetadata": obj.get("additionalMetadata"),
+                "triggerAt": obj.get("triggerAt"),
             }
         )
         return _obj

hatchet_sdk/clients/rest/models/scheduled_run_status.py

@@ -0,0 +1,42 @@
+# 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 ScheduledRunStatus(str, Enum):
+    """
+    ScheduledRunStatus
+    """
+
+    """
+    allowed enum values
+    """
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    SUCCEEDED = "SUCCEEDED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
+    QUEUED = "QUEUED"
+    SCHEDULED = "SCHEDULED"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ScheduledRunStatus from a JSON string"""
+        return cls(json.loads(json_str))

hatchet_sdk/clients/rest/models/scheduled_workflows.py

@@ -0,0 +1,153 @@
+# 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, StrictStr, field_validator
+from typing_extensions import Annotated, Self
+
+from hatchet_sdk.clients.rest.models.api_resource_meta import APIResourceMeta
+from hatchet_sdk.clients.rest.models.workflow_run_status import WorkflowRunStatus
+
+
+class ScheduledWorkflows(BaseModel):
+    """
+    ScheduledWorkflows
+    """  # noqa: E501
+
+    metadata: APIResourceMeta
+    tenant_id: StrictStr = Field(alias="tenantId")
+    workflow_version_id: StrictStr = Field(alias="workflowVersionId")
+    workflow_id: StrictStr = Field(alias="workflowId")
+    workflow_name: StrictStr = Field(alias="workflowName")
+    trigger_at: datetime = Field(alias="triggerAt")
+    input: Optional[Dict[str, Any]] = None
+    additional_metadata: Optional[Dict[str, Any]] = Field(
+        default=None, alias="additionalMetadata"
+    )
+    workflow_run_created_at: Optional[datetime] = Field(
+        default=None, alias="workflowRunCreatedAt"
+    )
+    workflow_run_name: Optional[StrictStr] = Field(
+        default=None, alias="workflowRunName"
+    )
+    workflow_run_status: Optional[WorkflowRunStatus] = Field(
+        default=None, alias="workflowRunStatus"
+    )
+    workflow_run_id: Optional[
+        Annotated[str, Field(min_length=36, strict=True, max_length=36)]
+    ] = Field(default=None, alias="workflowRunId")
+    method: StrictStr
+    __properties: ClassVar[List[str]] = [
+        "metadata",
+        "tenantId",
+        "workflowVersionId",
+        "workflowId",
+        "workflowName",
+        "triggerAt",
+        "input",
+        "additionalMetadata",
+        "workflowRunCreatedAt",
+        "workflowRunName",
+        "workflowRunStatus",
+        "workflowRunId",
+        "method",
+    ]
+
+    @field_validator("method")
+    def method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["DEFAULT", "API"]):
+            raise ValueError("must be one of enum values ('DEFAULT', 'API')")
+        return value
+
+    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 ScheduledWorkflows 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 ScheduledWorkflows 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
+                ),
+                "tenantId": obj.get("tenantId"),
+                "workflowVersionId": obj.get("workflowVersionId"),
+                "workflowId": obj.get("workflowId"),
+                "workflowName": obj.get("workflowName"),
+                "triggerAt": obj.get("triggerAt"),
+                "input": obj.get("input"),
+                "additionalMetadata": obj.get("additionalMetadata"),
+                "workflowRunCreatedAt": obj.get("workflowRunCreatedAt"),
+                "workflowRunName": obj.get("workflowRunName"),
+                "workflowRunStatus": obj.get("workflowRunStatus"),
+                "workflowRunId": obj.get("workflowRunId"),
+                "method": obj.get("method"),
+            }
+        )
+        return _obj