blaxel 0.2.33__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/request_duration_over_time_metric.py

@@ -1,97 +0,0 @@
-from typing import Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="RequestDurationOverTimeMetric")
-
-
-@_attrs_define
-class RequestDurationOverTimeMetric:
-    """Request duration over time metric
-
-    Attributes:
-        average (Union[Unset, float]): Average request duration
-        p50 (Union[Unset, float]): P50 request duration
-        p90 (Union[Unset, float]): P90 request duration
-        p99 (Union[Unset, float]): P99 request duration
-        timestamp (Union[Unset, str]): Timestamp
-    """
-
-    average: Union[Unset, float] = UNSET
-    p50: Union[Unset, float] = UNSET
-    p90: Union[Unset, float] = UNSET
-    p99: Union[Unset, float] = UNSET
-    timestamp: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        average = self.average
-
-        p50 = self.p50
-
-        p90 = self.p90
-
-        p99 = self.p99
-
-        timestamp = self.timestamp
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if average is not UNSET:
-            field_dict["average"] = average
-        if p50 is not UNSET:
-            field_dict["p50"] = p50
-        if p90 is not UNSET:
-            field_dict["p90"] = p90
-        if p99 is not UNSET:
-            field_dict["p99"] = p99
-        if timestamp is not UNSET:
-            field_dict["timestamp"] = timestamp
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        average = d.pop("average", UNSET)
-
-        p50 = d.pop("p50", UNSET)
-
-        p90 = d.pop("p90", UNSET)
-
-        p99 = d.pop("p99", UNSET)
-
-        timestamp = d.pop("timestamp", UNSET)
-
-        request_duration_over_time_metric = cls(
-            average=average,
-            p50=p50,
-            p90=p90,
-            p99=p99,
-            timestamp=timestamp,
-        )
-
-        request_duration_over_time_metric.additional_properties = d
-        return request_duration_over_time_metric
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_duration_over_time_metrics.py

@@ -1,84 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.request_duration_over_time_metric import RequestDurationOverTimeMetric
-
-
-T = TypeVar("T", bound="RequestDurationOverTimeMetrics")
-
-
-@_attrs_define
-class RequestDurationOverTimeMetrics:
-    """Request duration over time metrics
-
-    Attributes:
-        request_duration_over_time (Union[Unset, list['RequestDurationOverTimeMetric']]): Request duration over time
-    """
-
-    request_duration_over_time: Union[Unset, list["RequestDurationOverTimeMetric"]] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        request_duration_over_time: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.request_duration_over_time, Unset):
-            request_duration_over_time = []
-            for request_duration_over_time_item_data in self.request_duration_over_time:
-                if type(request_duration_over_time_item_data) is dict:
-                    request_duration_over_time_item = request_duration_over_time_item_data
-                else:
-                    request_duration_over_time_item = request_duration_over_time_item_data.to_dict()
-                request_duration_over_time.append(request_duration_over_time_item)
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if request_duration_over_time is not UNSET:
-            field_dict["requestDurationOverTime"] = request_duration_over_time
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.request_duration_over_time_metric import RequestDurationOverTimeMetric
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        request_duration_over_time = []
-        _request_duration_over_time = d.pop(
-            "requestDurationOverTime", d.pop("request_duration_over_time", UNSET)
-        )
-        for request_duration_over_time_item_data in _request_duration_over_time or []:
-            request_duration_over_time_item = RequestDurationOverTimeMetric.from_dict(
-                request_duration_over_time_item_data
-            )
-
-            request_duration_over_time.append(request_duration_over_time_item)
-
-        request_duration_over_time_metrics = cls(
-            request_duration_over_time=request_duration_over_time,
-        )
-
-        request_duration_over_time_metrics.additional_properties = d
-        return request_duration_over_time_metrics
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_total_by_origin_metric.py

@@ -1,129 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.request_total_by_origin_metric_request_total_by_origin import (
-        RequestTotalByOriginMetricRequestTotalByOrigin,
-    )
-    from ..models.request_total_by_origin_metric_request_total_by_origin_and_code import (
-        RequestTotalByOriginMetricRequestTotalByOriginAndCode,
-    )
-
-
-T = TypeVar("T", bound="RequestTotalByOriginMetric")
-
-
-@_attrs_define
-class RequestTotalByOriginMetric:
-    """Request total by origin metric
-
-    Attributes:
-        request_total_by_origin (Union[Unset, RequestTotalByOriginMetricRequestTotalByOrigin]): Request total by origin
-        request_total_by_origin_and_code (Union[Unset, RequestTotalByOriginMetricRequestTotalByOriginAndCode]): Request
-            total by origin and code
-    """
-
-    request_total_by_origin: Union[Unset, "RequestTotalByOriginMetricRequestTotalByOrigin"] = UNSET
-    request_total_by_origin_and_code: Union[
-        Unset, "RequestTotalByOriginMetricRequestTotalByOriginAndCode"
-    ] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        request_total_by_origin: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.request_total_by_origin
-            and not isinstance(self.request_total_by_origin, Unset)
-            and not isinstance(self.request_total_by_origin, dict)
-        ):
-            request_total_by_origin = self.request_total_by_origin.to_dict()
-        elif self.request_total_by_origin and isinstance(self.request_total_by_origin, dict):
-            request_total_by_origin = self.request_total_by_origin
-
-        request_total_by_origin_and_code: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.request_total_by_origin_and_code
-            and not isinstance(self.request_total_by_origin_and_code, Unset)
-            and not isinstance(self.request_total_by_origin_and_code, dict)
-        ):
-            request_total_by_origin_and_code = self.request_total_by_origin_and_code.to_dict()
-        elif self.request_total_by_origin_and_code and isinstance(
-            self.request_total_by_origin_and_code, dict
-        ):
-            request_total_by_origin_and_code = self.request_total_by_origin_and_code
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if request_total_by_origin is not UNSET:
-            field_dict["requestTotalByOrigin"] = request_total_by_origin
-        if request_total_by_origin_and_code is not UNSET:
-            field_dict["requestTotalByOriginAndCode"] = request_total_by_origin_and_code
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.request_total_by_origin_metric_request_total_by_origin import (
-            RequestTotalByOriginMetricRequestTotalByOrigin,
-        )
-        from ..models.request_total_by_origin_metric_request_total_by_origin_and_code import (
-            RequestTotalByOriginMetricRequestTotalByOriginAndCode,
-        )
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        _request_total_by_origin = d.pop(
-            "requestTotalByOrigin", d.pop("request_total_by_origin", UNSET)
-        )
-        request_total_by_origin: Union[Unset, RequestTotalByOriginMetricRequestTotalByOrigin]
-        if isinstance(_request_total_by_origin, Unset):
-            request_total_by_origin = UNSET
-        else:
-            request_total_by_origin = RequestTotalByOriginMetricRequestTotalByOrigin.from_dict(
-                _request_total_by_origin
-            )
-
-        _request_total_by_origin_and_code = d.pop(
-            "requestTotalByOriginAndCode", d.pop("request_total_by_origin_and_code", UNSET)
-        )
-        request_total_by_origin_and_code: Union[
-            Unset, RequestTotalByOriginMetricRequestTotalByOriginAndCode
-        ]
-        if isinstance(_request_total_by_origin_and_code, Unset):
-            request_total_by_origin_and_code = UNSET
-        else:
-            request_total_by_origin_and_code = (
-                RequestTotalByOriginMetricRequestTotalByOriginAndCode.from_dict(
-                    _request_total_by_origin_and_code
-                )
-            )
-
-        request_total_by_origin_metric = cls(
-            request_total_by_origin=request_total_by_origin,
-            request_total_by_origin_and_code=request_total_by_origin_and_code,
-        )
-
-        request_total_by_origin_metric.additional_properties = d
-        return request_total_by_origin_metric
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_total_by_origin_metric_request_total_by_origin.py

@@ -1,45 +0,0 @@
-from typing import Any, TypeVar
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="RequestTotalByOriginMetricRequestTotalByOrigin")
-
-
-@_attrs_define
-class RequestTotalByOriginMetricRequestTotalByOrigin:
-    """Request total by origin"""
-
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        request_total_by_origin_metric_request_total_by_origin = cls()
-
-        request_total_by_origin_metric_request_total_by_origin.additional_properties = d
-        return request_total_by_origin_metric_request_total_by_origin
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_total_by_origin_metric_request_total_by_origin_and_code.py

@@ -1,45 +0,0 @@
-from typing import Any, TypeVar
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="RequestTotalByOriginMetricRequestTotalByOriginAndCode")
-
-
-@_attrs_define
-class RequestTotalByOriginMetricRequestTotalByOriginAndCode:
-    """Request total by origin and code"""
-
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        request_total_by_origin_metric_request_total_by_origin_and_code = cls()
-
-        request_total_by_origin_metric_request_total_by_origin_and_code.additional_properties = d
-        return request_total_by_origin_metric_request_total_by_origin_and_code
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_total_metric.py

@@ -1,155 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.request_total_metric_request_total_per_code import (
-        RequestTotalMetricRequestTotalPerCode,
-    )
-    from ..models.request_total_metric_rps_per_code import RequestTotalMetricRpsPerCode
-    from ..models.request_total_response_data import RequestTotalResponseData
-
-
-T = TypeVar("T", bound="RequestTotalMetric")
-
-
-@_attrs_define
-class RequestTotalMetric:
-    """Metrics for request total
-
-    Attributes:
-        items (Union[Unset, list['RequestTotalResponseData']]): Historical requests for all resources globally
-        request_total (Union[Unset, float]): Number of requests for all resources globally
-        request_total_per_code (Union[Unset, RequestTotalMetricRequestTotalPerCode]): Number of requests for all
-            resources globally per code
-        rps (Union[Unset, float]): Number of requests per second for all resources globally
-        rps_per_code (Union[Unset, RequestTotalMetricRpsPerCode]): Number of requests for all resources globally
-    """
-
-    items: Union[Unset, list["RequestTotalResponseData"]] = UNSET
-    request_total: Union[Unset, float] = UNSET
-    request_total_per_code: Union[Unset, "RequestTotalMetricRequestTotalPerCode"] = UNSET
-    rps: Union[Unset, float] = UNSET
-    rps_per_code: Union[Unset, "RequestTotalMetricRpsPerCode"] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        items: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.items, Unset):
-            items = []
-            for items_item_data in self.items:
-                if type(items_item_data) is dict:
-                    items_item = items_item_data
-                else:
-                    items_item = items_item_data.to_dict()
-                items.append(items_item)
-
-        request_total = self.request_total
-
-        request_total_per_code: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.request_total_per_code
-            and not isinstance(self.request_total_per_code, Unset)
-            and not isinstance(self.request_total_per_code, dict)
-        ):
-            request_total_per_code = self.request_total_per_code.to_dict()
-        elif self.request_total_per_code and isinstance(self.request_total_per_code, dict):
-            request_total_per_code = self.request_total_per_code
-
-        rps = self.rps
-
-        rps_per_code: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.rps_per_code
-            and not isinstance(self.rps_per_code, Unset)
-            and not isinstance(self.rps_per_code, dict)
-        ):
-            rps_per_code = self.rps_per_code.to_dict()
-        elif self.rps_per_code and isinstance(self.rps_per_code, dict):
-            rps_per_code = self.rps_per_code
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if items is not UNSET:
-            field_dict["items"] = items
-        if request_total is not UNSET:
-            field_dict["requestTotal"] = request_total
-        if request_total_per_code is not UNSET:
-            field_dict["requestTotalPerCode"] = request_total_per_code
-        if rps is not UNSET:
-            field_dict["rps"] = rps
-        if rps_per_code is not UNSET:
-            field_dict["rpsPerCode"] = rps_per_code
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.request_total_metric_request_total_per_code import (
-            RequestTotalMetricRequestTotalPerCode,
-        )
-        from ..models.request_total_metric_rps_per_code import RequestTotalMetricRpsPerCode
-        from ..models.request_total_response_data import RequestTotalResponseData
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        items = []
-        _items = d.pop("items", UNSET)
-        for items_item_data in _items or []:
-            items_item = RequestTotalResponseData.from_dict(items_item_data)
-
-            items.append(items_item)
-
-        request_total = d.pop("requestTotal", d.pop("request_total", UNSET))
-
-        _request_total_per_code = d.pop(
-            "requestTotalPerCode", d.pop("request_total_per_code", UNSET)
-        )
-        request_total_per_code: Union[Unset, RequestTotalMetricRequestTotalPerCode]
-        if isinstance(_request_total_per_code, Unset):
-            request_total_per_code = UNSET
-        else:
-            request_total_per_code = RequestTotalMetricRequestTotalPerCode.from_dict(
-                _request_total_per_code
-            )
-
-        rps = d.pop("rps", UNSET)
-
-        _rps_per_code = d.pop("rpsPerCode", d.pop("rps_per_code", UNSET))
-        rps_per_code: Union[Unset, RequestTotalMetricRpsPerCode]
-        if isinstance(_rps_per_code, Unset):
-            rps_per_code = UNSET
-        else:
-            rps_per_code = RequestTotalMetricRpsPerCode.from_dict(_rps_per_code)
-
-        request_total_metric = cls(
-            items=items,
-            request_total=request_total,
-            request_total_per_code=request_total_per_code,
-            rps=rps,
-            rps_per_code=rps_per_code,
-        )
-
-        request_total_metric.additional_properties = d
-        return request_total_metric
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_total_metric_request_total_per_code.py

@@ -1,45 +0,0 @@
-from typing import Any, TypeVar
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="RequestTotalMetricRequestTotalPerCode")
-
-
-@_attrs_define
-class RequestTotalMetricRequestTotalPerCode:
-    """Number of requests for all resources globally per code"""
-
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        request_total_metric_request_total_per_code = cls()
-
-        request_total_metric_request_total_per_code.additional_properties = d
-        return request_total_metric_request_total_per_code
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

blaxel/core/client/models/request_total_metric_rps_per_code.py

@@ -1,45 +0,0 @@
-from typing import Any, TypeVar
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="RequestTotalMetricRpsPerCode")
-
-
-@_attrs_define
-class RequestTotalMetricRpsPerCode:
-    """Number of requests for all resources globally"""
-
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        request_total_metric_rps_per_code = cls()
-
-        request_total_metric_rps_per_code.additional_properties = d
-        return request_total_metric_rps_per_code
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties