blaxel 0.1.16__py3-none-any.whl → 0.1.17__py3-none-any.whl

blaxel/client/models/jobs_chart_value.py

@@ -0,0 +1,70 @@
+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="JobsChartValue")
+
+
+@_attrs_define
+class JobsChartValue:
+    """Jobs CPU usage
+
+    Attributes:
+        timestamp (Union[Unset, str]): Metric timestamp
+        value (Union[Unset, int]): Metric value
+    """
+
+    timestamp: Union[Unset, str] = UNSET
+    value: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timestamp = self.timestamp
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        timestamp = d.pop("timestamp", UNSET)
+
+        value = d.pop("value", UNSET)
+
+        jobs_chart_value = cls(
+            timestamp=timestamp,
+            value=value,
+        )
+
+        jobs_chart_value.additional_properties = d
+        return jobs_chart_value
+
+    @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/client/models/jobs_executions.py

@@ -0,0 +1,88 @@
+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="JobsExecutions")
+
+
+@_attrs_define
+class JobsExecutions:
+    """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:
+        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_executions = cls(
+            failed=failed,
+            running=running,
+            success=success,
+            total=total,
+        )
+
+        jobs_executions.additional_properties = d
+        return jobs_executions
+
+    @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/client/models/jobs_network_chart.py

@@ -0,0 +1,94 @@
+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="JobsNetworkChart")
+
+
+@_attrs_define
+class JobsNetworkChart:
+    """Jobs chart
+
+    Attributes:
+        received (Union[Unset, JobsChartValue]): Jobs CPU usage
+        sent (Union[Unset, JobsChartValue]): Jobs CPU usage
+    """
+
+    received: Union[Unset, "JobsChartValue"] = UNSET
+    sent: Union[Unset, "JobsChartValue"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        received: Union[Unset, dict[str, Any]] = UNSET
+        if self.received and not isinstance(self.received, Unset) and not isinstance(self.received, dict):
+            received = self.received.to_dict()
+        elif self.received and isinstance(self.received, dict):
+            received = self.received
+
+        sent: Union[Unset, dict[str, Any]] = UNSET
+        if self.sent and not isinstance(self.sent, Unset) and not isinstance(self.sent, dict):
+            sent = self.sent.to_dict()
+        elif self.sent and isinstance(self.sent, dict):
+            sent = self.sent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if received is not UNSET:
+            field_dict["received"] = received
+        if sent is not UNSET:
+            field_dict["sent"] = sent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.jobs_chart_value import JobsChartValue
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _received = d.pop("received", UNSET)
+        received: Union[Unset, JobsChartValue]
+        if isinstance(_received, Unset):
+            received = UNSET
+        else:
+            received = JobsChartValue.from_dict(_received)
+
+        _sent = d.pop("sent", UNSET)
+        sent: Union[Unset, JobsChartValue]
+        if isinstance(_sent, Unset):
+            sent = UNSET
+        else:
+            sent = JobsChartValue.from_dict(_sent)
+
+        jobs_network_chart = cls(
+            received=received,
+            sent=sent,
+        )
+
+        jobs_network_chart.additional_properties = d
+        return jobs_network_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/client/models/jobs_success_failed_chart.py

@@ -0,0 +1,139 @@
+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:
+        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/client/models/jobs_tasks.py

@@ -0,0 +1,88 @@
+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="JobsTasks")
+
+
+@_attrs_define
+class JobsTasks:
+    """Jobs tasks
+
+    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:
+        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_tasks = cls(
+            failed=failed,
+            running=running,
+            success=success,
+            total=total,
+        )
+
+        jobs_tasks.additional_properties = d
+        return jobs_tasks
+
+    @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/client/models/jobs_total.py

@@ -0,0 +1,97 @@
+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
+        retried (Union[Unset, int]): Retried executions
+        running (Union[Unset, int]): Running executions
+        success (Union[Unset, int]): Success executions
+        total (Union[Unset, int]): Total executions
+    """
+
+    failed: Union[Unset, int] = UNSET
+    retried: 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
+
+        retried = self.retried
+
+        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 retried is not UNSET:
+            field_dict["retried"] = retried
+        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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        failed = d.pop("failed", UNSET)
+
+        retried = d.pop("retried", UNSET)
+
+        running = d.pop("running", UNSET)
+
+        success = d.pop("success", UNSET)
+
+        total = d.pop("total", UNSET)
+
+        jobs_total = cls(
+            failed=failed,
+            retried=retried,
+            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/client/models/preview_spec.py

@@ -1,10 +1,15 @@
-from typing import Any, TypeVar, Union
+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.preview_spec_request_headers import PreviewSpecRequestHeaders
+    from ..models.preview_spec_response_headers import PreviewSpecResponseHeaders
+
+
 T = TypeVar("T", bound="PreviewSpec")
 
 
@@ -16,12 +21,18 @@ class PreviewSpec:
         port (Union[Unset, int]): Port of the preview
         prefix_url (Union[Unset, str]): Prefix URL
         public (Union[Unset, bool]): Whether the preview is public
+        request_headers (Union[Unset, PreviewSpecRequestHeaders]): Those headers will be set in all requests to your
+            preview. This is especially useful to set the Authorization header.
+        response_headers (Union[Unset, PreviewSpecResponseHeaders]): Those headers will be set in all responses of your
+            preview. This is especially useful to set the CORS headers.
         url (Union[Unset, str]): URL of the preview
     """
 
     port: Union[Unset, int] = UNSET
     prefix_url: Union[Unset, str] = UNSET
     public: Union[Unset, bool] = UNSET
+    request_headers: Union[Unset, "PreviewSpecRequestHeaders"] = UNSET
+    response_headers: Union[Unset, "PreviewSpecResponseHeaders"] = UNSET
     url: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -32,6 +43,26 @@ class PreviewSpec:
 
         public = self.public
 
+        request_headers: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.request_headers
+            and not isinstance(self.request_headers, Unset)
+            and not isinstance(self.request_headers, dict)
+        ):
+            request_headers = self.request_headers.to_dict()
+        elif self.request_headers and isinstance(self.request_headers, dict):
+            request_headers = self.request_headers
+
+        response_headers: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.response_headers
+            and not isinstance(self.response_headers, Unset)
+            and not isinstance(self.response_headers, dict)
+        ):
+            response_headers = self.response_headers.to_dict()
+        elif self.response_headers and isinstance(self.response_headers, dict):
+            response_headers = self.response_headers
+
         url = self.url
 
         field_dict: dict[str, Any] = {}
@@ -43,6 +74,10 @@ class PreviewSpec:
             field_dict["prefixUrl"] = prefix_url
         if public is not UNSET:
             field_dict["public"] = public
+        if request_headers is not UNSET:
+            field_dict["requestHeaders"] = request_headers
+        if response_headers is not UNSET:
+            field_dict["responseHeaders"] = response_headers
         if url is not UNSET:
             field_dict["url"] = url
 
@@ -50,6 +85,9 @@ class PreviewSpec:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.preview_spec_request_headers import PreviewSpecRequestHeaders
+        from ..models.preview_spec_response_headers import PreviewSpecResponseHeaders
+
         if not src_dict:
             return None
         d = src_dict.copy()
@@ -59,12 +97,28 @@ class PreviewSpec:
 
         public = d.pop("public", UNSET)
 
+        _request_headers = d.pop("requestHeaders", UNSET)
+        request_headers: Union[Unset, PreviewSpecRequestHeaders]
+        if isinstance(_request_headers, Unset):
+            request_headers = UNSET
+        else:
+            request_headers = PreviewSpecRequestHeaders.from_dict(_request_headers)
+
+        _response_headers = d.pop("responseHeaders", UNSET)
+        response_headers: Union[Unset, PreviewSpecResponseHeaders]
+        if isinstance(_response_headers, Unset):
+            response_headers = UNSET
+        else:
+            response_headers = PreviewSpecResponseHeaders.from_dict(_response_headers)
+
         url = d.pop("url", UNSET)
 
         preview_spec = cls(
             port=port,
             prefix_url=prefix_url,
             public=public,
+            request_headers=request_headers,
+            response_headers=response_headers,
             url=url,
         )