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

hatchet_sdk/clients/cloud_rest/models/tenant_billing_state_get200_response_subscription.py

@@ -1,114 +0,0 @@
-# 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, field_validator
-from typing_extensions import Self
-
-
-class TenantBillingStateGet200ResponseSubscription(BaseModel):
-    """
-    The subscription associated with this policy.
-    """  # noqa: E501
-
-    plan: Optional[StrictStr] = Field(
-        default=None,
-        description="The plan code associated with the tenant subscription.",
-    )
-    period: Optional[StrictStr] = Field(
-        default=None, description="The period associated with the tenant subscription."
-    )
-    status: Optional[StrictStr] = Field(
-        default=None, description="The status of the tenant subscription."
-    )
-    note: Optional[StrictStr] = Field(
-        default=None, description="A note associated with the tenant subscription."
-    )
-    __properties: ClassVar[List[str]] = ["plan", "period", "status", "note"]
-
-    @field_validator("status")
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(["active", "pending", "terminated", "canceled"]):
-            raise ValueError(
-                "must be one of enum values ('active', 'pending', 'terminated', 'canceled')"
-            )
-        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 TenantBillingStateGet200ResponseSubscription 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,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TenantBillingStateGet200ResponseSubscription from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate(
-            {
-                "plan": obj.get("plan"),
-                "period": obj.get("period"),
-                "status": obj.get("status"),
-                "note": obj.get("note"),
-            }
-        )
-        return _obj

hatchet_sdk/clients/cloud_rest/models/workflow_run_events_get_metrics200_response.py

@@ -1,107 +0,0 @@
-# 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
-from typing_extensions import Self
-
-from hatchet_sdk.clients.cloud_rest.models.workflow_run_events_get_metrics200_response_results_inner import (
-    WorkflowRunEventsGetMetrics200ResponseResultsInner,
-)
-
-
-class WorkflowRunEventsGetMetrics200Response(BaseModel):
-    """
-    WorkflowRunEventsGetMetrics200Response
-    """  # noqa: E501
-
-    results: Optional[List[WorkflowRunEventsGetMetrics200ResponseResultsInner]] = None
-    __properties: ClassVar[List[str]] = ["results"]
-
-    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 WorkflowRunEventsGetMetrics200Response 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 results (list)
-        _items = []
-        if self.results:
-            for _item in self.results:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict["results"] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of WorkflowRunEventsGetMetrics200Response from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate(
-            {
-                "results": (
-                    [
-                        WorkflowRunEventsGetMetrics200ResponseResultsInner.from_dict(
-                            _item
-                        )
-                        for _item in obj["results"]
-                    ]
-                    if obj.get("results") is not None
-                    else None
-                )
-            }
-        )
-        return _obj

hatchet_sdk/clients/cloud_rest/models/workflow_run_events_get_metrics200_response_results_inner.py

@@ -1,105 +0,0 @@
-# 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
-from typing_extensions import Self
-
-
-class WorkflowRunEventsGetMetrics200ResponseResultsInner(BaseModel):
-    """
-    WorkflowRunEventsGetMetrics200ResponseResultsInner
-    """  # noqa: E501
-
-    time: datetime
-    pending: StrictInt = Field(alias="PENDING")
-    running: StrictInt = Field(alias="RUNNING")
-    succeeded: StrictInt = Field(alias="SUCCEEDED")
-    failed: StrictInt = Field(alias="FAILED")
-    queued: StrictInt = Field(alias="QUEUED")
-    __properties: ClassVar[List[str]] = [
-        "time",
-        "PENDING",
-        "RUNNING",
-        "SUCCEEDED",
-        "FAILED",
-        "QUEUED",
-    ]
-
-    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 WorkflowRunEventsGetMetrics200ResponseResultsInner 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,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of WorkflowRunEventsGetMetrics200ResponseResultsInner from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate(
-            {
-                "time": obj.get("time"),
-                "PENDING": obj.get("PENDING"),
-                "RUNNING": obj.get("RUNNING"),
-                "SUCCEEDED": obj.get("SUCCEEDED"),
-                "FAILED": obj.get("FAILED"),
-                "QUEUED": obj.get("QUEUED"),
-            }
-        )
-        return _obj

hatchet_sdk/clients/cloud_rest/rest.py

@@ -1,182 +0,0 @@
-# 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
-
-
-import io
-import json
-import re
-import ssl
-from typing import Optional, Union
-
-import aiohttp
-import aiohttp_retry
-
-from hatchet_sdk.clients.cloud_rest.exceptions import ApiException, ApiValueError
-
-RESTResponseType = aiohttp.ClientResponse
-
-ALLOW_RETRY_METHODS = frozenset({"DELETE", "GET", "HEAD", "OPTIONS", "PUT", "TRACE"})
-
-
-class RESTResponse(io.IOBase):
-
-    def __init__(self, resp) -> None:
-        self.response = resp
-        self.status = resp.status
-        self.reason = resp.reason
-        self.data = None
-
-    async def read(self):
-        if self.data is None:
-            self.data = await self.response.read()
-        return self.data
-
-    def getheaders(self):
-        """Returns a CIMultiDictProxy of the response headers."""
-        return self.response.headers
-
-    def getheader(self, name, default=None):
-        """Returns a given response header."""
-        return self.response.headers.get(name, default)
-
-
-class RESTClientObject:
-
-    def __init__(self, configuration) -> None:
-
-        # maxsize is number of requests to host that are allowed in parallel
-        maxsize = configuration.connection_pool_maxsize
-
-        ssl_context = ssl.create_default_context(cafile=configuration.ssl_ca_cert)
-        if configuration.cert_file:
-            ssl_context.load_cert_chain(
-                configuration.cert_file, keyfile=configuration.key_file
-            )
-
-        if not configuration.verify_ssl:
-            ssl_context.check_hostname = False
-            ssl_context.verify_mode = ssl.CERT_NONE
-
-        connector = aiohttp.TCPConnector(limit=maxsize, ssl=ssl_context)
-
-        self.proxy = configuration.proxy
-        self.proxy_headers = configuration.proxy_headers
-
-        # https pool manager
-        self.pool_manager = aiohttp.ClientSession(connector=connector, trust_env=True)
-
-        retries = configuration.retries
-        self.retry_client: Optional[aiohttp_retry.RetryClient]
-        if retries is not None:
-            self.retry_client = aiohttp_retry.RetryClient(
-                client_session=self.pool_manager,
-                retry_options=aiohttp_retry.ExponentialRetry(
-                    attempts=retries, factor=0.0, start_timeout=0.0, max_timeout=120.0
-                ),
-            )
-        else:
-            self.retry_client = None
-
-    async def close(self):
-        await self.pool_manager.close()
-        if self.retry_client is not None:
-            await self.retry_client.close()
-
-    async def request(
-        self,
-        method,
-        url,
-        headers=None,
-        body=None,
-        post_params=None,
-        _request_timeout=None,
-    ):
-        """Execute request
-
-        :param method: http request method
-        :param url: http request url
-        :param headers: http request headers
-        :param body: request json body, for `application/json`
-        :param post_params: request post parameters,
-                            `application/x-www-form-urlencoded`
-                            and `multipart/form-data`
-        :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.
-        """
-        method = method.upper()
-        assert method in ["GET", "HEAD", "DELETE", "POST", "PUT", "PATCH", "OPTIONS"]
-
-        if post_params and body:
-            raise ApiValueError(
-                "body parameter cannot be used with post_params parameter."
-            )
-
-        post_params = post_params or {}
-        headers = headers or {}
-        # url already contains the URL query string
-        timeout = _request_timeout or 5 * 60
-
-        if "Content-Type" not in headers:
-            headers["Content-Type"] = "application/json"
-
-        args = {"method": method, "url": url, "timeout": timeout, "headers": headers}
-
-        if self.proxy:
-            args["proxy"] = self.proxy
-        if self.proxy_headers:
-            args["proxy_headers"] = self.proxy_headers
-
-        # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
-        if method in ["POST", "PUT", "PATCH", "OPTIONS", "DELETE"]:
-            if re.search("json", headers["Content-Type"], re.IGNORECASE):
-                if body is not None:
-                    body = json.dumps(body)
-                args["data"] = body
-            elif headers["Content-Type"] == "application/x-www-form-urlencoded":
-                args["data"] = aiohttp.FormData(post_params)
-            elif headers["Content-Type"] == "multipart/form-data":
-                # must del headers['Content-Type'], or the correct
-                # Content-Type which generated by aiohttp
-                del headers["Content-Type"]
-                data = aiohttp.FormData()
-                for param in post_params:
-                    k, v = param
-                    if isinstance(v, tuple) and len(v) == 3:
-                        data.add_field(k, value=v[1], filename=v[0], content_type=v[2])
-                    else:
-                        data.add_field(k, v)
-                args["data"] = data
-
-            # Pass a `bytes` parameter directly in the body to support
-            # other content types than Json when `body` argument is provided
-            # in serialized form
-            elif isinstance(body, bytes):
-                args["data"] = body
-            else:
-                # Cannot generate the request from given parameters
-                msg = """Cannot prepare a request message for provided
-                         arguments. Please check that your arguments match
-                         declared content type."""
-                raise ApiException(status=0, reason=msg)
-
-        pool_manager: Union[aiohttp.ClientSession, aiohttp_retry.RetryClient]
-        if self.retry_client is not None and method in ALLOW_RETRY_METHODS:
-            pool_manager = self.retry_client
-        else:
-            pool_manager = self.pool_manager
-
-        r = await pool_manager.request(**args)
-
-        return RESTResponse(r)

hatchet_sdk/compute/configs.py

@@ -1,34 +0,0 @@
-import hashlib
-from typing import Annotated, Optional
-
-from pydantic import BaseModel, Field, StrictStr
-
-
-class Compute(BaseModel):
-    pool: Optional[str] = Field(
-        default="default",
-        description="The name of the compute pool to use",
-    )
-    num_replicas: Annotated[int, Field(le=1000, strict=True, ge=0)] = Field(
-        default=1, alias="num_replicas"
-    )
-    # TODO: change to ManagedWorkerRegion
-    regions: Optional[list[str]] = Field(
-        default=None, description="The regions to deploy the worker to"
-    )
-    cpu_kind: StrictStr = Field(
-        description="The kind of CPU to use for the worker", alias="cpu_kind"
-    )
-    cpus: Annotated[int, Field(le=64, strict=True, ge=1)] = Field(
-        description="The number of CPUs to use for the worker"
-    )
-    memory_mb: Annotated[int, Field(le=65536, strict=True, ge=1024)] = Field(
-        description="The amount of memory in MB to use for the worker",
-        alias="memory_mb",
-    )
-
-    def __json__(self):
-        return self.model_dump_json()
-
-    def hash(self):
-        return hashlib.sha256(self.__json__().encode()).hexdigest()

hatchet_sdk/compute/managed_compute.py

@@ -1,111 +0,0 @@
-import os
-import sys
-from typing import Any, Callable, Dict, List
-
-from hatchet_sdk.client import Client
-from hatchet_sdk.clients.cloud_rest.models.infra_as_code_create_request import (
-    InfraAsCodeCreateRequest,
-)
-from hatchet_sdk.clients.cloud_rest.models.managed_worker_create_request_runtime_config import (
-    ManagedWorkerCreateRequestRuntimeConfig,
-)
-from hatchet_sdk.compute.configs import Compute
-from hatchet_sdk.logger import logger
-
-# TODO why is this not generating
-# from hatchet_sdk.clients.cloud_rest.models.managed_worker_create_request import ManagedWorkerRegion
-
-
-class ManagedCompute:
-    def __init__(
-        self, actions: Dict[str, Callable[..., Any]], client: Client, max_runs: int = 1
-    ):
-        self.actions = actions
-        self.client = client
-        self.max_runs = max_runs
-        self.configs = self.get_compute_configs(self.actions)
-        self.cloud_register_enabled = os.environ.get("HATCHET_CLOUD_REGISTER_ID")
-
-        if len(self.configs) == 0:
-            logger.debug(
-                "no compute configs found, skipping cloud registration and running all actions locally."
-            )
-            return
-
-        if self.cloud_register_enabled is None:
-            logger.warning("managed cloud compute plan:")
-            for compute in self.configs:
-                logger.warning(f"    ----------------------------")
-                logger.warning(f"    actions: {', '.join(compute.actions)}")
-                logger.warning(f"    num replicas: {compute.num_replicas}")
-                logger.warning(f"    cpu kind: {compute.cpu_kind}")
-                logger.warning(f"    cpus: {compute.cpus}")
-                logger.warning(f"    memory mb: {compute.memory_mb}")
-                logger.warning(f"    regions: {compute.regions}")
-
-            logger.warning(
-                "NOTICE: local mode detected, skipping cloud registration and running all actions locally."
-            )
-
-    def get_compute_configs(
-        self, actions: Dict[str, Callable[..., Any]]
-    ) -> List[ManagedWorkerCreateRequestRuntimeConfig]:
-        """
-        Builds a map of compute hashes to compute configs and lists of actions that correspond to each compute hash.
-        """
-        map: Dict[str, ManagedWorkerCreateRequestRuntimeConfig] = {}
-
-        try:
-            for action, func in actions.items():
-                compute = func._step_compute
-
-                if compute is None:
-                    continue
-
-                key = compute.hash()
-                if key not in map:
-                    map[key] = ManagedWorkerCreateRequestRuntimeConfig(
-                        actions=[],
-                        num_replicas=compute.num_replicas,
-                        cpu_kind=compute.cpu_kind,
-                        cpus=compute.cpus,
-                        memory_mb=compute.memory_mb,
-                        regions=compute.regions,
-                        slots=self.max_runs,
-                    )
-                map[key].actions.append(action)
-
-            return list(map.values())
-        except Exception as e:
-            logger.error(f"Error getting compute configs: {e}")
-            return []
-
-    async def cloud_register(self):
-
-        # if the environment variable HATCHET_CLOUD_REGISTER_ID is set, use it and exit
-        if self.cloud_register_enabled is not None:
-            logger.info(
-                f"Registering cloud compute plan with ID: {self.cloud_register_enabled}"
-            )
-
-            try:
-                if len(self.configs) == 0:
-                    logger.warning(
-                        "No actions to register, skipping cloud registration."
-                    )
-                    return
-
-                req = InfraAsCodeCreateRequest(runtime_configs=self.configs)
-
-                res = (
-                    await self.client.rest.aio.managed_worker_api.infra_as_code_create(
-                        infra_as_code_request=self.cloud_register_enabled,
-                        infra_as_code_create_request=req,
-                        _request_timeout=10,
-                    )
-                )
-
-                sys.exit(0)
-            except Exception as e:
-                print("ERROR", e)
-                sys.exit(1)