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

blaxel/core/client/models/jobs_success_failed_chart.py

@@ -1,147 +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.jobs_chart_value import JobsChartValue
-
-
-T = TypeVar("T", bound="JobsSuccessFailedChart")
-
-
-@_attrs_define
-class JobsSuccessFailedChart:
-    """Jobs chart
-
-    Attributes:
-        failed (Union[Unset, JobsChartValue]): Jobs CPU usage
-        retried (Union[Unset, JobsChartValue]): Jobs CPU usage
-        success (Union[Unset, JobsChartValue]): Jobs CPU usage
-        timestamp (Union[Unset, str]): Metric timestamp
-        total (Union[Unset, JobsChartValue]): Jobs CPU usage
-    """
-
-    failed: Union[Unset, "JobsChartValue"] = UNSET
-    retried: Union[Unset, "JobsChartValue"] = UNSET
-    success: Union[Unset, "JobsChartValue"] = UNSET
-    timestamp: Union[Unset, str] = UNSET
-    total: Union[Unset, "JobsChartValue"] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        failed: Union[Unset, dict[str, Any]] = UNSET
-        if self.failed and not isinstance(self.failed, Unset) and not isinstance(self.failed, dict):
-            failed = self.failed.to_dict()
-        elif self.failed and isinstance(self.failed, dict):
-            failed = self.failed
-
-        retried: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.retried
-            and not isinstance(self.retried, Unset)
-            and not isinstance(self.retried, dict)
-        ):
-            retried = self.retried.to_dict()
-        elif self.retried and isinstance(self.retried, dict):
-            retried = self.retried
-
-        success: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.success
-            and not isinstance(self.success, Unset)
-            and not isinstance(self.success, dict)
-        ):
-            success = self.success.to_dict()
-        elif self.success and isinstance(self.success, dict):
-            success = self.success
-
-        timestamp = self.timestamp
-
-        total: Union[Unset, dict[str, Any]] = UNSET
-        if self.total and not isinstance(self.total, Unset) and not isinstance(self.total, dict):
-            total = self.total.to_dict()
-        elif self.total and isinstance(self.total, dict):
-            total = self.total
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if failed is not UNSET:
-            field_dict["failed"] = failed
-        if retried is not UNSET:
-            field_dict["retried"] = retried
-        if success is not UNSET:
-            field_dict["success"] = success
-        if timestamp is not UNSET:
-            field_dict["timestamp"] = timestamp
-        if total is not UNSET:
-            field_dict["total"] = total
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.jobs_chart_value import JobsChartValue
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        _failed = d.pop("failed", UNSET)
-        failed: Union[Unset, JobsChartValue]
-        if isinstance(_failed, Unset):
-            failed = UNSET
-        else:
-            failed = JobsChartValue.from_dict(_failed)
-
-        _retried = d.pop("retried", UNSET)
-        retried: Union[Unset, JobsChartValue]
-        if isinstance(_retried, Unset):
-            retried = UNSET
-        else:
-            retried = JobsChartValue.from_dict(_retried)
-
-        _success = d.pop("success", UNSET)
-        success: Union[Unset, JobsChartValue]
-        if isinstance(_success, Unset):
-            success = UNSET
-        else:
-            success = JobsChartValue.from_dict(_success)
-
-        timestamp = d.pop("timestamp", UNSET)
-
-        _total = d.pop("total", UNSET)
-        total: Union[Unset, JobsChartValue]
-        if isinstance(_total, Unset):
-            total = UNSET
-        else:
-            total = JobsChartValue.from_dict(_total)
-
-        jobs_success_failed_chart = cls(
-            failed=failed,
-            retried=retried,
-            success=success,
-            timestamp=timestamp,
-            total=total,
-        )
-
-        jobs_success_failed_chart.additional_properties = d
-        return jobs_success_failed_chart
-
-    @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/jobs_total.py

@@ -1,88 +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="JobsTotal")
-
-
-@_attrs_define
-class JobsTotal:
-    """Jobs executions
-
-    Attributes:
-        failed (Union[Unset, int]): Failed executions
-        running (Union[Unset, int]): Running executions
-        success (Union[Unset, int]): Success executions
-        total (Union[Unset, int]): Total executions
-    """
-
-    failed: Union[Unset, int] = UNSET
-    running: Union[Unset, int] = UNSET
-    success: Union[Unset, int] = UNSET
-    total: Union[Unset, int] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        failed = self.failed
-
-        running = self.running
-
-        success = self.success
-
-        total = self.total
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if failed is not UNSET:
-            field_dict["failed"] = failed
-        if running is not UNSET:
-            field_dict["running"] = running
-        if success is not UNSET:
-            field_dict["success"] = success
-        if total is not UNSET:
-            field_dict["total"] = total
-
-        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()
-        failed = d.pop("failed", UNSET)
-
-        running = d.pop("running", UNSET)
-
-        success = d.pop("success", UNSET)
-
-        total = d.pop("total", UNSET)
-
-        jobs_total = cls(
-            failed=failed,
-            running=running,
-            success=success,
-            total=total,
-        )
-
-        jobs_total.additional_properties = d
-        return jobs_total
-
-    @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/last_n_requests_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="LastNRequestsMetric")
-
-
-@_attrs_define
-class LastNRequestsMetric:
-    """Last N requests
-
-    Attributes:
-        date (Union[Unset, str]): Timestamp
-        status_code (Union[Unset, str]): Status code
-        workload_id (Union[Unset, str]): Workload ID
-        workload_type (Union[Unset, str]): Workload type
-        workspace (Union[Unset, str]): Workspace
-    """
-
-    date: Union[Unset, str] = UNSET
-    status_code: Union[Unset, str] = UNSET
-    workload_id: Union[Unset, str] = UNSET
-    workload_type: Union[Unset, str] = UNSET
-    workspace: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        date = self.date
-
-        status_code = self.status_code
-
-        workload_id = self.workload_id
-
-        workload_type = self.workload_type
-
-        workspace = self.workspace
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if date is not UNSET:
-            field_dict["date"] = date
-        if status_code is not UNSET:
-            field_dict["statusCode"] = status_code
-        if workload_id is not UNSET:
-            field_dict["workloadId"] = workload_id
-        if workload_type is not UNSET:
-            field_dict["workloadType"] = workload_type
-        if workspace is not UNSET:
-            field_dict["workspace"] = workspace
-
-        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()
-        date = d.pop("date", UNSET)
-
-        status_code = d.pop("statusCode", d.pop("status_code", UNSET))
-
-        workload_id = d.pop("workloadId", d.pop("workload_id", UNSET))
-
-        workload_type = d.pop("workloadType", d.pop("workload_type", UNSET))
-
-        workspace = d.pop("workspace", UNSET)
-
-        last_n_requests_metric = cls(
-            date=date,
-            status_code=status_code,
-            workload_id=workload_id,
-            workload_type=workload_type,
-            workspace=workspace,
-        )
-
-        last_n_requests_metric.additional_properties = d
-        return last_n_requests_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/latency_metric.py

@@ -1,148 +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.histogram_bucket import HistogramBucket
-    from ..models.histogram_stats import HistogramStats
-
-
-T = TypeVar("T", bound="LatencyMetric")
-
-
-@_attrs_define
-class LatencyMetric:
-    """Latency metrics
-
-    Attributes:
-        global_histogram (Union[Unset, list['HistogramBucket']]): Global histogram
-        global_stats (Union[Unset, HistogramStats]): Histogram stats
-        histogram_per_code (Union[Unset, HistogramBucket]): Histogram bucket
-        stats_per_code (Union[Unset, HistogramStats]): Histogram stats
-    """
-
-    global_histogram: Union[Unset, list["HistogramBucket"]] = UNSET
-    global_stats: Union[Unset, "HistogramStats"] = UNSET
-    histogram_per_code: Union[Unset, "HistogramBucket"] = UNSET
-    stats_per_code: Union[Unset, "HistogramStats"] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        global_histogram: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.global_histogram, Unset):
-            global_histogram = []
-            for global_histogram_item_data in self.global_histogram:
-                if type(global_histogram_item_data) is dict:
-                    global_histogram_item = global_histogram_item_data
-                else:
-                    global_histogram_item = global_histogram_item_data.to_dict()
-                global_histogram.append(global_histogram_item)
-
-        global_stats: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.global_stats
-            and not isinstance(self.global_stats, Unset)
-            and not isinstance(self.global_stats, dict)
-        ):
-            global_stats = self.global_stats.to_dict()
-        elif self.global_stats and isinstance(self.global_stats, dict):
-            global_stats = self.global_stats
-
-        histogram_per_code: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.histogram_per_code
-            and not isinstance(self.histogram_per_code, Unset)
-            and not isinstance(self.histogram_per_code, dict)
-        ):
-            histogram_per_code = self.histogram_per_code.to_dict()
-        elif self.histogram_per_code and isinstance(self.histogram_per_code, dict):
-            histogram_per_code = self.histogram_per_code
-
-        stats_per_code: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.stats_per_code
-            and not isinstance(self.stats_per_code, Unset)
-            and not isinstance(self.stats_per_code, dict)
-        ):
-            stats_per_code = self.stats_per_code.to_dict()
-        elif self.stats_per_code and isinstance(self.stats_per_code, dict):
-            stats_per_code = self.stats_per_code
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if global_histogram is not UNSET:
-            field_dict["globalHistogram"] = global_histogram
-        if global_stats is not UNSET:
-            field_dict["globalStats"] = global_stats
-        if histogram_per_code is not UNSET:
-            field_dict["histogramPerCode"] = histogram_per_code
-        if stats_per_code is not UNSET:
-            field_dict["statsPerCode"] = stats_per_code
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.histogram_bucket import HistogramBucket
-        from ..models.histogram_stats import HistogramStats
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        global_histogram = []
-        _global_histogram = d.pop("globalHistogram", d.pop("global_histogram", UNSET))
-        for global_histogram_item_data in _global_histogram or []:
-            global_histogram_item = HistogramBucket.from_dict(global_histogram_item_data)
-
-            global_histogram.append(global_histogram_item)
-
-        _global_stats = d.pop("globalStats", d.pop("global_stats", UNSET))
-        global_stats: Union[Unset, HistogramStats]
-        if isinstance(_global_stats, Unset):
-            global_stats = UNSET
-        else:
-            global_stats = HistogramStats.from_dict(_global_stats)
-
-        _histogram_per_code = d.pop("histogramPerCode", d.pop("histogram_per_code", UNSET))
-        histogram_per_code: Union[Unset, HistogramBucket]
-        if isinstance(_histogram_per_code, Unset):
-            histogram_per_code = UNSET
-        else:
-            histogram_per_code = HistogramBucket.from_dict(_histogram_per_code)
-
-        _stats_per_code = d.pop("statsPerCode", d.pop("stats_per_code", UNSET))
-        stats_per_code: Union[Unset, HistogramStats]
-        if isinstance(_stats_per_code, Unset):
-            stats_per_code = UNSET
-        else:
-            stats_per_code = HistogramStats.from_dict(_stats_per_code)
-
-        latency_metric = cls(
-            global_histogram=global_histogram,
-            global_stats=global_stats,
-            histogram_per_code=histogram_per_code,
-            stats_per_code=stats_per_code,
-        )
-
-        latency_metric.additional_properties = d
-        return latency_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/logs_response.py

@@ -1,63 +0,0 @@
-from typing import Any, TypeVar, Union, cast
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="LogsResponse")
-
-
-@_attrs_define
-class LogsResponse:
-    """Response for logs
-
-    Attributes:
-        data (Union[Unset, list[Any]]): Data
-    """
-
-    data: Union[Unset, list[Any]] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        data: Union[Unset, list[Any]] = UNSET
-        if not isinstance(self.data, Unset):
-            data = self.data
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if data is not UNSET:
-            field_dict["data"] = data
-
-        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()
-        data = cast(list[Any], d.pop("data", UNSET))
-
-        logs_response = cls(
-            data=data,
-        )
-
-        logs_response.additional_properties = d
-        return logs_response
-
-    @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/logs_response_data.py

@@ -1,99 +0,0 @@
-from typing import Any, TypeVar, Union, cast
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="LogsResponseData")
-
-
-@_attrs_define
-class LogsResponseData:
-    """Response data for logs
-
-    Attributes:
-        body (Union[Unset, str]): Body of the log
-        log_attributes (Union[Unset, list[Any]]): Log attributes
-        severity_number (Union[Unset, int]): Severity number of the log
-        timestamp (Union[Unset, str]): Timestamp of the log
-        trace_id (Union[Unset, str]): Trace ID of the log
-    """
-
-    body: Union[Unset, str] = UNSET
-    log_attributes: Union[Unset, list[Any]] = UNSET
-    severity_number: Union[Unset, int] = UNSET
-    timestamp: Union[Unset, str] = UNSET
-    trace_id: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        body = self.body
-
-        log_attributes: Union[Unset, list[Any]] = UNSET
-        if not isinstance(self.log_attributes, Unset):
-            log_attributes = self.log_attributes
-
-        severity_number = self.severity_number
-
-        timestamp = self.timestamp
-
-        trace_id = self.trace_id
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if body is not UNSET:
-            field_dict["body"] = body
-        if log_attributes is not UNSET:
-            field_dict["logAttributes"] = log_attributes
-        if severity_number is not UNSET:
-            field_dict["severityNumber"] = severity_number
-        if timestamp is not UNSET:
-            field_dict["timestamp"] = timestamp
-        if trace_id is not UNSET:
-            field_dict["traceId"] = trace_id
-
-        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()
-        body = d.pop("body", UNSET)
-
-        log_attributes = cast(list[Any], d.pop("logAttributes", d.pop("log_attributes", UNSET)))
-
-        severity_number = d.pop("severityNumber", d.pop("severity_number", UNSET))
-
-        timestamp = d.pop("timestamp", UNSET)
-
-        trace_id = d.pop("traceId", d.pop("trace_id", UNSET))
-
-        logs_response_data = cls(
-            body=body,
-            log_attributes=log_attributes,
-            severity_number=severity_number,
-            timestamp=timestamp,
-            trace_id=trace_id,
-        )
-
-        logs_response_data.additional_properties = d
-        return logs_response_data
-
-    @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/mcp_definition_form.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="MCPDefinitionForm")
-
-
-@_attrs_define
-class MCPDefinitionForm:
-    """Form of the artifact"""
-
-    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()
-        mcp_definition_form = cls()
-
-        mcp_definition_form.additional_properties = d
-        return mcp_definition_form
-
-    @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