blaxel 0.1.9rc35__py3-none-any.whl → 0.1.9rc37__py3-none-any.whl

blaxel/client/models/resource_metrics.py

@@ -12,7 +12,11 @@ if TYPE_CHECKING:
     from ..models.request_duration_over_time_metrics import RequestDurationOverTimeMetrics
     from ..models.request_total_by_origin_metric import RequestTotalByOriginMetric
     from ..models.resource_metrics_request_total_per_code import ResourceMetricsRequestTotalPerCode
+    from ..models.resource_metrics_request_total_per_code_previous import (
+        ResourceMetricsRequestTotalPerCodePrevious,
+    )
     from ..models.resource_metrics_rps_per_code import ResourceMetricsRpsPerCode
+    from ..models.resource_metrics_rps_per_code_previous import ResourceMetricsRpsPerCodePrevious
     from ..models.time_to_first_token_over_time_metrics import TimeToFirstTokenOverTimeMetrics
     from ..models.token_rate_metrics import TokenRateMetrics
     from ..models.token_total_metric import TokenTotalMetric
@@ -26,41 +30,69 @@ class ResourceMetrics:
     """Metrics for a single resource deployment (eg. model deployment, function deployment)
 
     Attributes:
+        inference_errors_global (Union[Unset, list['Metric']]): Array of metrics
         inference_global (Union[Unset, list['Metric']]): Array of metrics
         last_n_requests (Union[Unset, list['Metric']]): Array of metrics
         latency (Union[Unset, LatencyMetric]): Latency metrics
+        latency_previous (Union[Unset, LatencyMetric]): Latency metrics
         memory_allocation (Union[Unset, MemoryAllocationMetric]): Metrics for memory allocation
         model_ttft (Union[Unset, LatencyMetric]): Latency metrics
         model_ttft_over_time (Union[Unset, TimeToFirstTokenOverTimeMetrics]): Time to first token over time metrics
         request_duration_over_time (Union[Unset, RequestDurationOverTimeMetrics]): Request duration over time metrics
         request_total (Union[Unset, float]): Number of requests for the resource globally
         request_total_by_origin (Union[Unset, RequestTotalByOriginMetric]): Request total by origin metric
+        request_total_by_origin_previous (Union[Unset, RequestTotalByOriginMetric]): Request total by origin metric
         request_total_per_code (Union[Unset, ResourceMetricsRequestTotalPerCode]): Number of requests for the resource
             globally per code
+        request_total_per_code_previous (Union[Unset, ResourceMetricsRequestTotalPerCodePrevious]): Number of requests
+            for the resource globally per code for the previous period
+        request_total_previous (Union[Unset, float]): Number of requests for the resource globally for the previous
+            period
         rps (Union[Unset, float]): Number of requests per second for the resource globally
         rps_per_code (Union[Unset, ResourceMetricsRpsPerCode]): Number of requests per second for the resource globally
             per code
+        rps_per_code_previous (Union[Unset, ResourceMetricsRpsPerCodePrevious]): Number of requests per second for the
+            resource globally per code for the previous period
+        rps_previous (Union[Unset, float]): Number of requests per second for the resource globally for the previous
+            period
         token_rate (Union[Unset, TokenRateMetrics]): Token rate metrics
         token_total (Union[Unset, TokenTotalMetric]): Token total metric
     """
 
+    inference_errors_global: Union[Unset, list["Metric"]] = UNSET
     inference_global: Union[Unset, list["Metric"]] = UNSET
     last_n_requests: Union[Unset, list["Metric"]] = UNSET
     latency: Union[Unset, "LatencyMetric"] = UNSET
+    latency_previous: Union[Unset, "LatencyMetric"] = UNSET
     memory_allocation: Union[Unset, "MemoryAllocationMetric"] = UNSET
     model_ttft: Union[Unset, "LatencyMetric"] = UNSET
     model_ttft_over_time: Union[Unset, "TimeToFirstTokenOverTimeMetrics"] = UNSET
     request_duration_over_time: Union[Unset, "RequestDurationOverTimeMetrics"] = UNSET
     request_total: Union[Unset, float] = UNSET
     request_total_by_origin: Union[Unset, "RequestTotalByOriginMetric"] = UNSET
+    request_total_by_origin_previous: Union[Unset, "RequestTotalByOriginMetric"] = UNSET
     request_total_per_code: Union[Unset, "ResourceMetricsRequestTotalPerCode"] = UNSET
+    request_total_per_code_previous: Union[Unset, "ResourceMetricsRequestTotalPerCodePrevious"] = UNSET
+    request_total_previous: Union[Unset, float] = UNSET
     rps: Union[Unset, float] = UNSET
     rps_per_code: Union[Unset, "ResourceMetricsRpsPerCode"] = UNSET
+    rps_per_code_previous: Union[Unset, "ResourceMetricsRpsPerCodePrevious"] = UNSET
+    rps_previous: Union[Unset, float] = UNSET
     token_rate: Union[Unset, "TokenRateMetrics"] = UNSET
     token_total: Union[Unset, "TokenTotalMetric"] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        inference_errors_global: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.inference_errors_global, Unset):
+            inference_errors_global = []
+            for componentsschemas_array_metric_item_data in self.inference_errors_global:
+                if type(componentsschemas_array_metric_item_data) == dict:
+                    componentsschemas_array_metric_item = componentsschemas_array_metric_item_data
+                else:
+                    componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
+                inference_errors_global.append(componentsschemas_array_metric_item)
+
         inference_global: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.inference_global, Unset):
             inference_global = []
@@ -87,6 +119,16 @@ class ResourceMetrics:
         elif self.latency and isinstance(self.latency, dict):
             latency = self.latency
 
+        latency_previous: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.latency_previous
+            and not isinstance(self.latency_previous, Unset)
+            and not isinstance(self.latency_previous, dict)
+        ):
+            latency_previous = self.latency_previous.to_dict()
+        elif self.latency_previous and isinstance(self.latency_previous, dict):
+            latency_previous = self.latency_previous
+
         memory_allocation: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.memory_allocation
@@ -135,6 +177,16 @@ class ResourceMetrics:
         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_previous: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.request_total_by_origin_previous
+            and not isinstance(self.request_total_by_origin_previous, Unset)
+            and not isinstance(self.request_total_by_origin_previous, dict)
+        ):
+            request_total_by_origin_previous = self.request_total_by_origin_previous.to_dict()
+        elif self.request_total_by_origin_previous and isinstance(self.request_total_by_origin_previous, dict):
+            request_total_by_origin_previous = self.request_total_by_origin_previous
+
         request_total_per_code: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.request_total_per_code
@@ -145,6 +197,18 @@ class ResourceMetrics:
         elif self.request_total_per_code and isinstance(self.request_total_per_code, dict):
             request_total_per_code = self.request_total_per_code
 
+        request_total_per_code_previous: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.request_total_per_code_previous
+            and not isinstance(self.request_total_per_code_previous, Unset)
+            and not isinstance(self.request_total_per_code_previous, dict)
+        ):
+            request_total_per_code_previous = self.request_total_per_code_previous.to_dict()
+        elif self.request_total_per_code_previous and isinstance(self.request_total_per_code_previous, dict):
+            request_total_per_code_previous = self.request_total_per_code_previous
+
+        request_total_previous = self.request_total_previous
+
         rps = self.rps
 
         rps_per_code: Union[Unset, dict[str, Any]] = UNSET
@@ -153,6 +217,18 @@ class ResourceMetrics:
         elif self.rps_per_code and isinstance(self.rps_per_code, dict):
             rps_per_code = self.rps_per_code
 
+        rps_per_code_previous: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.rps_per_code_previous
+            and not isinstance(self.rps_per_code_previous, Unset)
+            and not isinstance(self.rps_per_code_previous, dict)
+        ):
+            rps_per_code_previous = self.rps_per_code_previous.to_dict()
+        elif self.rps_per_code_previous and isinstance(self.rps_per_code_previous, dict):
+            rps_per_code_previous = self.rps_per_code_previous
+
+        rps_previous = self.rps_previous
+
         token_rate: Union[Unset, dict[str, Any]] = UNSET
         if self.token_rate and not isinstance(self.token_rate, Unset) and not isinstance(self.token_rate, dict):
             token_rate = self.token_rate.to_dict()
@@ -168,12 +244,16 @@ class ResourceMetrics:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if inference_errors_global is not UNSET:
+            field_dict["inferenceErrorsGlobal"] = inference_errors_global
         if inference_global is not UNSET:
             field_dict["inferenceGlobal"] = inference_global
         if last_n_requests is not UNSET:
             field_dict["lastNRequests"] = last_n_requests
         if latency is not UNSET:
             field_dict["latency"] = latency
+        if latency_previous is not UNSET:
+            field_dict["latencyPrevious"] = latency_previous
         if memory_allocation is not UNSET:
             field_dict["memoryAllocation"] = memory_allocation
         if model_ttft is not UNSET:
@@ -186,12 +266,22 @@ class ResourceMetrics:
             field_dict["requestTotal"] = request_total
         if request_total_by_origin is not UNSET:
             field_dict["requestTotalByOrigin"] = request_total_by_origin
+        if request_total_by_origin_previous is not UNSET:
+            field_dict["requestTotalByOriginPrevious"] = request_total_by_origin_previous
         if request_total_per_code is not UNSET:
             field_dict["requestTotalPerCode"] = request_total_per_code
+        if request_total_per_code_previous is not UNSET:
+            field_dict["requestTotalPerCodePrevious"] = request_total_per_code_previous
+        if request_total_previous is not UNSET:
+            field_dict["requestTotalPrevious"] = request_total_previous
         if rps is not UNSET:
             field_dict["rps"] = rps
         if rps_per_code is not UNSET:
             field_dict["rpsPerCode"] = rps_per_code
+        if rps_per_code_previous is not UNSET:
+            field_dict["rpsPerCodePrevious"] = rps_per_code_previous
+        if rps_previous is not UNSET:
+            field_dict["rpsPrevious"] = rps_previous
         if token_rate is not UNSET:
             field_dict["tokenRate"] = token_rate
         if token_total is not UNSET:
@@ -209,7 +299,13 @@ class ResourceMetrics:
         from ..models.resource_metrics_request_total_per_code import (
             ResourceMetricsRequestTotalPerCode,
         )
+        from ..models.resource_metrics_request_total_per_code_previous import (
+            ResourceMetricsRequestTotalPerCodePrevious,
+        )
         from ..models.resource_metrics_rps_per_code import ResourceMetricsRpsPerCode
+        from ..models.resource_metrics_rps_per_code_previous import (
+            ResourceMetricsRpsPerCodePrevious,
+        )
         from ..models.time_to_first_token_over_time_metrics import TimeToFirstTokenOverTimeMetrics
         from ..models.token_rate_metrics import TokenRateMetrics
         from ..models.token_total_metric import TokenTotalMetric
@@ -217,6 +313,13 @@ class ResourceMetrics:
         if not src_dict:
             return None
         d = src_dict.copy()
+        inference_errors_global = []
+        _inference_errors_global = d.pop("inferenceErrorsGlobal", UNSET)
+        for componentsschemas_array_metric_item_data in _inference_errors_global or []:
+            componentsschemas_array_metric_item = Metric.from_dict(componentsschemas_array_metric_item_data)
+
+            inference_errors_global.append(componentsschemas_array_metric_item)
+
         inference_global = []
         _inference_global = d.pop("inferenceGlobal", UNSET)
         for componentsschemas_array_metric_item_data in _inference_global or []:
@@ -238,6 +341,13 @@ class ResourceMetrics:
         else:
             latency = LatencyMetric.from_dict(_latency)
 
+        _latency_previous = d.pop("latencyPrevious", UNSET)
+        latency_previous: Union[Unset, LatencyMetric]
+        if isinstance(_latency_previous, Unset):
+            latency_previous = UNSET
+        else:
+            latency_previous = LatencyMetric.from_dict(_latency_previous)
+
         _memory_allocation = d.pop("memoryAllocation", UNSET)
         memory_allocation: Union[Unset, MemoryAllocationMetric]
         if isinstance(_memory_allocation, Unset):
@@ -275,6 +385,13 @@ class ResourceMetrics:
         else:
             request_total_by_origin = RequestTotalByOriginMetric.from_dict(_request_total_by_origin)
 
+        _request_total_by_origin_previous = d.pop("requestTotalByOriginPrevious", UNSET)
+        request_total_by_origin_previous: Union[Unset, RequestTotalByOriginMetric]
+        if isinstance(_request_total_by_origin_previous, Unset):
+            request_total_by_origin_previous = UNSET
+        else:
+            request_total_by_origin_previous = RequestTotalByOriginMetric.from_dict(_request_total_by_origin_previous)
+
         _request_total_per_code = d.pop("requestTotalPerCode", UNSET)
         request_total_per_code: Union[Unset, ResourceMetricsRequestTotalPerCode]
         if isinstance(_request_total_per_code, Unset):
@@ -282,6 +399,17 @@ class ResourceMetrics:
         else:
             request_total_per_code = ResourceMetricsRequestTotalPerCode.from_dict(_request_total_per_code)
 
+        _request_total_per_code_previous = d.pop("requestTotalPerCodePrevious", UNSET)
+        request_total_per_code_previous: Union[Unset, ResourceMetricsRequestTotalPerCodePrevious]
+        if isinstance(_request_total_per_code_previous, Unset):
+            request_total_per_code_previous = UNSET
+        else:
+            request_total_per_code_previous = ResourceMetricsRequestTotalPerCodePrevious.from_dict(
+                _request_total_per_code_previous
+            )
+
+        request_total_previous = d.pop("requestTotalPrevious", UNSET)
+
         rps = d.pop("rps", UNSET)
 
         _rps_per_code = d.pop("rpsPerCode", UNSET)
@@ -291,6 +419,15 @@ class ResourceMetrics:
         else:
             rps_per_code = ResourceMetricsRpsPerCode.from_dict(_rps_per_code)
 
+        _rps_per_code_previous = d.pop("rpsPerCodePrevious", UNSET)
+        rps_per_code_previous: Union[Unset, ResourceMetricsRpsPerCodePrevious]
+        if isinstance(_rps_per_code_previous, Unset):
+            rps_per_code_previous = UNSET
+        else:
+            rps_per_code_previous = ResourceMetricsRpsPerCodePrevious.from_dict(_rps_per_code_previous)
+
+        rps_previous = d.pop("rpsPrevious", UNSET)
+
         _token_rate = d.pop("tokenRate", UNSET)
         token_rate: Union[Unset, TokenRateMetrics]
         if isinstance(_token_rate, Unset):
@@ -306,18 +443,25 @@ class ResourceMetrics:
             token_total = TokenTotalMetric.from_dict(_token_total)
 
         resource_metrics = cls(
+            inference_errors_global=inference_errors_global,
             inference_global=inference_global,
             last_n_requests=last_n_requests,
             latency=latency,
+            latency_previous=latency_previous,
             memory_allocation=memory_allocation,
             model_ttft=model_ttft,
             model_ttft_over_time=model_ttft_over_time,
             request_duration_over_time=request_duration_over_time,
             request_total=request_total,
             request_total_by_origin=request_total_by_origin,
+            request_total_by_origin_previous=request_total_by_origin_previous,
             request_total_per_code=request_total_per_code,
+            request_total_per_code_previous=request_total_per_code_previous,
+            request_total_previous=request_total_previous,
             rps=rps,
             rps_per_code=rps_per_code,
+            rps_per_code_previous=rps_per_code_previous,
+            rps_previous=rps_previous,
             token_rate=token_rate,
             token_total=token_total,
         )

blaxel/client/models/resource_metrics_request_total_per_code_previous.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ResourceMetricsRequestTotalPerCodePrevious")
+
+
+@_attrs_define
+class ResourceMetricsRequestTotalPerCodePrevious:
+    """Number of requests for the resource globally per code for the previous period"""
+
+    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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        resource_metrics_request_total_per_code_previous = cls()
+
+        resource_metrics_request_total_per_code_previous.additional_properties = d
+        return resource_metrics_request_total_per_code_previous
+
+    @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/resource_metrics_rps_per_code_previous.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ResourceMetricsRpsPerCodePrevious")
+
+
+@_attrs_define
+class ResourceMetricsRpsPerCodePrevious:
+    """Number of requests per second for the resource globally per code for the previous period"""
+
+    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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        resource_metrics_rps_per_code_previous = cls()
+
+        resource_metrics_rps_per_code_previous.additional_properties = d
+        return resource_metrics_rps_per_code_previous
+
+    @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/runtime.py

@@ -6,6 +6,8 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+    from ..models.port import Port
+    from ..models.runtime_configuration import RuntimeConfiguration
     from ..models.runtime_startup_probe import RuntimeStartupProbe
 
 
@@ -19,33 +21,44 @@ class Runtime:
     Attributes:
         args (Union[Unset, list[Any]]): The arguments to pass to the deployment runtime
         command (Union[Unset, list[Any]]): The command to run the deployment
+        configuration (Union[Unset, RuntimeConfiguration]): The configuration for the deployment
         cpu (Union[Unset, int]): The CPU for the deployment in cores, only available for private cluster
         endpoint_name (Union[Unset, str]): Endpoint Name of the model. In case of hf_private_endpoint, it is the
             endpoint name. In case of hf_public_endpoint, it is not used.
         envs (Union[Unset, list[Any]]): The env variables to set in the deployment. Should be a list of Kubernetes
             EnvVar types
+        generation (Union[Unset, str]): The generation of the deployment
         image (Union[Unset, str]): The Docker image for the deployment
+        max_scale (Union[Unset, int]): The minimum number of replicas for the deployment. Can be 0 or 1 (in which case
+            the deployment is always running in at least one location).
         memory (Union[Unset, int]): The memory for the deployment in MB
         metric_port (Union[Unset, int]): The port to serve the metrics on
+        min_scale (Union[Unset, int]): The maximum number of replicas for the deployment.
         model (Union[Unset, str]): The slug name of the origin model at HuggingFace.
         organization (Union[Unset, str]): The organization of the model
-        serving_port (Union[Unset, int]): The port to serve the model on
+        ports (Union[Unset, list['Port']]): Set of ports for a resource
         startup_probe (Union[Unset, RuntimeStartupProbe]): The readiness probe. Should be a Kubernetes Probe type
+        timeout (Union[Unset, int]): The timeout for the deployment in seconds
         type_ (Union[Unset, str]): The type of origin for the deployment (hf_private_endpoint, hf_public_endpoint)
     """
 
     args: Union[Unset, list[Any]] = UNSET
     command: Union[Unset, list[Any]] = UNSET
+    configuration: Union[Unset, "RuntimeConfiguration"] = UNSET
     cpu: Union[Unset, int] = UNSET
     endpoint_name: Union[Unset, str] = UNSET
     envs: Union[Unset, list[Any]] = UNSET
+    generation: Union[Unset, str] = UNSET
     image: Union[Unset, str] = UNSET
+    max_scale: Union[Unset, int] = UNSET
     memory: Union[Unset, int] = UNSET
     metric_port: Union[Unset, int] = UNSET
+    min_scale: Union[Unset, int] = UNSET
     model: Union[Unset, str] = UNSET
     organization: Union[Unset, str] = UNSET
-    serving_port: Union[Unset, int] = UNSET
+    ports: Union[Unset, list["Port"]] = UNSET
     startup_probe: Union[Unset, "RuntimeStartupProbe"] = UNSET
+    timeout: Union[Unset, int] = UNSET
     type_: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -58,6 +71,16 @@ class Runtime:
         if not isinstance(self.command, Unset):
             command = self.command
 
+        configuration: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.configuration
+            and not isinstance(self.configuration, Unset)
+            and not isinstance(self.configuration, dict)
+        ):
+            configuration = self.configuration.to_dict()
+        elif self.configuration and isinstance(self.configuration, dict):
+            configuration = self.configuration
+
         cpu = self.cpu
 
         endpoint_name = self.endpoint_name
@@ -66,17 +89,31 @@ class Runtime:
         if not isinstance(self.envs, Unset):
             envs = self.envs
 
+        generation = self.generation
+
         image = self.image
 
+        max_scale = self.max_scale
+
         memory = self.memory
 
         metric_port = self.metric_port
 
+        min_scale = self.min_scale
+
         model = self.model
 
         organization = self.organization
 
-        serving_port = self.serving_port
+        ports: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.ports, Unset):
+            ports = []
+            for componentsschemas_ports_item_data in self.ports:
+                if type(componentsschemas_ports_item_data) == dict:
+                    componentsschemas_ports_item = componentsschemas_ports_item_data
+                else:
+                    componentsschemas_ports_item = componentsschemas_ports_item_data.to_dict()
+                ports.append(componentsschemas_ports_item)
 
         startup_probe: Union[Unset, dict[str, Any]] = UNSET
         if (
@@ -88,6 +125,8 @@ class Runtime:
         elif self.startup_probe and isinstance(self.startup_probe, dict):
             startup_probe = self.startup_probe
 
+        timeout = self.timeout
+
         type_ = self.type_
 
         field_dict: dict[str, Any] = {}
@@ -97,26 +136,36 @@ class Runtime:
             field_dict["args"] = args
         if command is not UNSET:
             field_dict["command"] = command
+        if configuration is not UNSET:
+            field_dict["configuration"] = configuration
         if cpu is not UNSET:
             field_dict["cpu"] = cpu
         if endpoint_name is not UNSET:
             field_dict["endpointName"] = endpoint_name
         if envs is not UNSET:
             field_dict["envs"] = envs
+        if generation is not UNSET:
+            field_dict["generation"] = generation
         if image is not UNSET:
             field_dict["image"] = image
+        if max_scale is not UNSET:
+            field_dict["maxScale"] = max_scale
         if memory is not UNSET:
             field_dict["memory"] = memory
         if metric_port is not UNSET:
             field_dict["metricPort"] = metric_port
+        if min_scale is not UNSET:
+            field_dict["minScale"] = min_scale
         if model is not UNSET:
             field_dict["model"] = model
         if organization is not UNSET:
             field_dict["organization"] = organization
-        if serving_port is not UNSET:
-            field_dict["servingPort"] = serving_port
+        if ports is not UNSET:
+            field_dict["ports"] = ports
         if startup_probe is not UNSET:
             field_dict["startupProbe"] = startup_probe
+        if timeout is not UNSET:
+            field_dict["timeout"] = timeout
         if type_ is not UNSET:
             field_dict["type"] = type_
 
@@ -124,6 +173,8 @@ class Runtime:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.port import Port
+        from ..models.runtime_configuration import RuntimeConfiguration
         from ..models.runtime_startup_probe import RuntimeStartupProbe
 
         if not src_dict:
@@ -133,23 +184,41 @@ class Runtime:
 
         command = cast(list[Any], d.pop("command", UNSET))
 
+        _configuration = d.pop("configuration", UNSET)
+        configuration: Union[Unset, RuntimeConfiguration]
+        if isinstance(_configuration, Unset):
+            configuration = UNSET
+        else:
+            configuration = RuntimeConfiguration.from_dict(_configuration)
+
         cpu = d.pop("cpu", UNSET)
 
         endpoint_name = d.pop("endpointName", UNSET)
 
         envs = cast(list[Any], d.pop("envs", UNSET))
 
+        generation = d.pop("generation", UNSET)
+
         image = d.pop("image", UNSET)
 
+        max_scale = d.pop("maxScale", UNSET)
+
         memory = d.pop("memory", UNSET)
 
         metric_port = d.pop("metricPort", UNSET)
 
+        min_scale = d.pop("minScale", UNSET)
+
         model = d.pop("model", UNSET)
 
         organization = d.pop("organization", UNSET)
 
-        serving_port = d.pop("servingPort", UNSET)
+        ports = []
+        _ports = d.pop("ports", UNSET)
+        for componentsschemas_ports_item_data in _ports or []:
+            componentsschemas_ports_item = Port.from_dict(componentsschemas_ports_item_data)
+
+            ports.append(componentsschemas_ports_item)
 
         _startup_probe = d.pop("startupProbe", UNSET)
         startup_probe: Union[Unset, RuntimeStartupProbe]
@@ -158,21 +227,28 @@ class Runtime:
         else:
             startup_probe = RuntimeStartupProbe.from_dict(_startup_probe)
 
+        timeout = d.pop("timeout", UNSET)
+
         type_ = d.pop("type", UNSET)
 
         runtime = cls(
             args=args,
             command=command,
+            configuration=configuration,
             cpu=cpu,
             endpoint_name=endpoint_name,
             envs=envs,
+            generation=generation,
             image=image,
+            max_scale=max_scale,
             memory=memory,
             metric_port=metric_port,
+            min_scale=min_scale,
             model=model,
             organization=organization,
-            serving_port=serving_port,
+            ports=ports,
             startup_probe=startup_probe,
+            timeout=timeout,
             type_=type_,
         )
 

blaxel/client/models/runtime_configuration.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RuntimeConfiguration")
+
+
+@_attrs_define
+class RuntimeConfiguration:
+    """The configuration for the deployment"""
+
+    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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        runtime_configuration = cls()
+
+        runtime_configuration.additional_properties = d
+        return runtime_configuration
+
+    @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