blaxel 0.2.31rc120__py3-none-any.whl → 0.2.32__py3-none-any.whl

blaxel/core/client/models/request_total_metric.py

@@ -37,7 +37,6 @@ class RequestTotalMetric:
     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 = []
@@ -63,7 +62,11 @@ class RequestTotalMetric:
         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):
+        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
@@ -85,7 +88,7 @@ class RequestTotalMetric:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         from ..models.request_total_metric_request_total_per_code import (
             RequestTotalMetricRequestTotalPerCode,
         )
@@ -102,18 +105,22 @@ class RequestTotalMetric:
 
             items.append(items_item)
 
-        request_total = d.pop("requestTotal", UNSET)
+        request_total = d.pop("requestTotal", d.pop("request_total", UNSET))
 
-        _request_total_per_code = d.pop("requestTotalPerCode", 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)
+            request_total_per_code = RequestTotalMetricRequestTotalPerCode.from_dict(
+                _request_total_per_code
+            )
 
         rps = d.pop("rps", UNSET)
 
-        _rps_per_code = d.pop("rpsPerCode", 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

blaxel/core/client/models/request_total_metric_request_total_per_code.py

@@ -19,7 +19,7 @@ class RequestTotalMetricRequestTotalPerCode:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/request_total_metric_rps_per_code.py

@@ -19,7 +19,7 @@ class RequestTotalMetricRpsPerCode:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/request_total_response_data.py

@@ -55,17 +55,17 @@ class RequestTotalResponseData:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    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 = d.pop("requestTotal", UNSET)
+        request_total = d.pop("requestTotal", d.pop("request_total", UNSET))
 
-        status_code = d.pop("statusCode", UNSET)
+        status_code = d.pop("statusCode", d.pop("status_code", UNSET))
 
-        workload_id = d.pop("workloadId", UNSET)
+        workload_id = d.pop("workloadId", d.pop("workload_id", UNSET))
 
-        workload_type = d.pop("workloadType", UNSET)
+        workload_type = d.pop("workloadType", d.pop("workload_type", UNSET))
 
         workspace = d.pop("workspace", UNSET)
 

blaxel/core/client/models/resource.py

@@ -55,19 +55,21 @@ class Resource:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()
-        infrastructure_generation = d.pop("infrastructureGeneration", UNSET)
+        infrastructure_generation = d.pop(
+            "infrastructureGeneration", d.pop("infrastructure_generation", UNSET)
+        )
 
         name = d.pop("name", UNSET)
 
-        type_ = d.pop("type", UNSET)
+        type_ = d.pop("type", d.pop("type_", UNSET))
 
         workspace = d.pop("workspace", UNSET)
 
-        workspace_id = d.pop("workspaceId", UNSET)
+        workspace_id = d.pop("workspaceId", d.pop("workspace_id", UNSET))
 
         resource = cls(
             infrastructure_generation=infrastructure_generation,

blaxel/core/client/models/resource_log.py

@@ -49,7 +49,7 @@ class ResourceLog:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/resource_log_chart.py

@@ -79,7 +79,7 @@ class ResourceLogChart:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/resource_log_response.py

@@ -47,7 +47,7 @@ class ResourceLogResponse:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()
@@ -55,7 +55,7 @@ class ResourceLogResponse:
 
         logs = cast(list[Any], d.pop("logs", UNSET))
 
-        total_count = d.pop("totalCount", UNSET)
+        total_count = d.pop("totalCount", d.pop("total_count", UNSET))
 
         resource_log_response = cls(
             chart=chart,

blaxel/core/client/models/resource_metrics.py

@@ -82,7 +82,9 @@ class ResourceMetrics:
     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_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
@@ -95,7 +97,6 @@ class ResourceMetrics:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         billable_time: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.billable_time
@@ -113,7 +114,9 @@ class ResourceMetrics:
                 if type(componentsschemas_array_metric_item_data) is dict:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data
                 else:
-                    componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
+                    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
@@ -123,7 +126,9 @@ class ResourceMetrics:
                 if type(componentsschemas_array_metric_item_data) is dict:
                     componentsschemas_array_metric_item = componentsschemas_array_metric_item_data
                 else:
-                    componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
+                    componentsschemas_array_metric_item = (
+                        componentsschemas_array_metric_item_data.to_dict()
+                    )
                 inference_global.append(componentsschemas_array_metric_item)
 
         last_n_requests: Union[Unset, list[dict[str, Any]]] = UNSET
@@ -137,7 +142,11 @@ class ResourceMetrics:
                 last_n_requests.append(last_n_requests_item)
 
         latency: Union[Unset, dict[str, Any]] = UNSET
-        if self.latency and not isinstance(self.latency, Unset) and not isinstance(self.latency, dict):
+        if (
+            self.latency
+            and not isinstance(self.latency, Unset)
+            and not isinstance(self.latency, dict)
+        ):
             latency = self.latency.to_dict()
         elif self.latency and isinstance(self.latency, dict):
             latency = self.latency
@@ -163,7 +172,11 @@ class ResourceMetrics:
             memory_allocation = self.memory_allocation
 
         model_ttft: Union[Unset, dict[str, Any]] = UNSET
-        if self.model_ttft and not isinstance(self.model_ttft, Unset) and not isinstance(self.model_ttft, dict):
+        if (
+            self.model_ttft
+            and not isinstance(self.model_ttft, Unset)
+            and not isinstance(self.model_ttft, dict)
+        ):
             model_ttft = self.model_ttft.to_dict()
         elif self.model_ttft and isinstance(self.model_ttft, dict):
             model_ttft = self.model_ttft
@@ -207,7 +220,9 @@ class ResourceMetrics:
             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):
+        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
@@ -227,7 +242,9 @@ class ResourceMetrics:
             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):
+        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
@@ -235,7 +252,11 @@ class ResourceMetrics:
         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):
+        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
@@ -273,13 +294,21 @@ class ResourceMetrics:
                 sandboxes_ram_usage.append(sandboxes_ram_usage_item)
 
         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):
+        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()
         elif self.token_rate and isinstance(self.token_rate, dict):
             token_rate = self.token_rate
 
         token_total: Union[Unset, dict[str, Any]] = UNSET
-        if self.token_total and not isinstance(self.token_total, Unset) and not isinstance(self.token_total, dict):
+        if (
+            self.token_total
+            and not isinstance(self.token_total, Unset)
+            and not isinstance(self.token_total, dict)
+        ):
             token_total = self.token_total.to_dict()
         elif self.token_total and isinstance(self.token_total, dict):
             token_total = self.token_total
@@ -339,7 +368,7 @@ class ResourceMetrics:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         from ..models.billable_time_metric import BillableTimeMetric
         from ..models.jobs_chart_value import JobsChartValue
         from ..models.last_n_requests_metric import LastNRequestsMetric
@@ -366,7 +395,7 @@ class ResourceMetrics:
         if not src_dict:
             return None
         d = src_dict.copy()
-        _billable_time = d.pop("billableTime", UNSET)
+        _billable_time = d.pop("billableTime", d.pop("billable_time", UNSET))
         billable_time: Union[Unset, BillableTimeMetric]
         if isinstance(_billable_time, Unset):
             billable_time = UNSET
@@ -374,21 +403,27 @@ class ResourceMetrics:
             billable_time = BillableTimeMetric.from_dict(_billable_time)
 
         inference_errors_global = []
-        _inference_errors_global = d.pop("inferenceErrorsGlobal", UNSET)
+        _inference_errors_global = d.pop(
+            "inferenceErrorsGlobal", d.pop("inference_errors_global", UNSET)
+        )
         for componentsschemas_array_metric_item_data in _inference_errors_global or []:
-            componentsschemas_array_metric_item = Metric.from_dict(componentsschemas_array_metric_item_data)
+            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)
+        _inference_global = d.pop("inferenceGlobal", d.pop("inference_global", UNSET))
         for componentsschemas_array_metric_item_data in _inference_global or []:
-            componentsschemas_array_metric_item = Metric.from_dict(componentsschemas_array_metric_item_data)
+            componentsschemas_array_metric_item = Metric.from_dict(
+                componentsschemas_array_metric_item_data
+            )
 
             inference_global.append(componentsschemas_array_metric_item)
 
         last_n_requests = []
-        _last_n_requests = d.pop("lastNRequests", UNSET)
+        _last_n_requests = d.pop("lastNRequests", d.pop("last_n_requests", UNSET))
         for last_n_requests_item_data in _last_n_requests or []:
             last_n_requests_item = LastNRequestsMetric.from_dict(last_n_requests_item_data)
 
@@ -401,65 +436,81 @@ class ResourceMetrics:
         else:
             latency = LatencyMetric.from_dict(_latency)
 
-        _latency_previous = d.pop("latencyPrevious", UNSET)
+        _latency_previous = d.pop("latencyPrevious", d.pop("latency_previous", 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 = d.pop("memoryAllocation", d.pop("memory_allocation", UNSET))
         memory_allocation: Union[Unset, MemoryAllocationMetric]
         if isinstance(_memory_allocation, Unset):
             memory_allocation = UNSET
         else:
             memory_allocation = MemoryAllocationMetric.from_dict(_memory_allocation)
 
-        _model_ttft = d.pop("modelTtft", UNSET)
+        _model_ttft = d.pop("modelTtft", d.pop("model_ttft", UNSET))
         model_ttft: Union[Unset, LatencyMetric]
         if isinstance(_model_ttft, Unset):
             model_ttft = UNSET
         else:
             model_ttft = LatencyMetric.from_dict(_model_ttft)
 
-        _model_ttft_over_time = d.pop("modelTtftOverTime", UNSET)
+        _model_ttft_over_time = d.pop("modelTtftOverTime", d.pop("model_ttft_over_time", UNSET))
         model_ttft_over_time: Union[Unset, TimeToFirstTokenOverTimeMetrics]
         if isinstance(_model_ttft_over_time, Unset):
             model_ttft_over_time = UNSET
         else:
             model_ttft_over_time = TimeToFirstTokenOverTimeMetrics.from_dict(_model_ttft_over_time)
 
-        _request_duration_over_time = d.pop("requestDurationOverTime", UNSET)
+        _request_duration_over_time = d.pop(
+            "requestDurationOverTime", d.pop("request_duration_over_time", UNSET)
+        )
         request_duration_over_time: Union[Unset, RequestDurationOverTimeMetrics]
         if isinstance(_request_duration_over_time, Unset):
             request_duration_over_time = UNSET
         else:
-            request_duration_over_time = RequestDurationOverTimeMetrics.from_dict(_request_duration_over_time)
+            request_duration_over_time = RequestDurationOverTimeMetrics.from_dict(
+                _request_duration_over_time
+            )
 
-        request_total = d.pop("requestTotal", UNSET)
+        request_total = d.pop("requestTotal", d.pop("request_total", UNSET))
 
-        _request_total_by_origin = d.pop("requestTotalByOrigin", UNSET)
+        _request_total_by_origin = d.pop(
+            "requestTotalByOrigin", d.pop("request_total_by_origin", UNSET)
+        )
         request_total_by_origin: Union[Unset, RequestTotalByOriginMetric]
         if isinstance(_request_total_by_origin, Unset):
             request_total_by_origin = UNSET
         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 = d.pop(
+            "requestTotalByOriginPrevious", d.pop("request_total_by_origin_previous", 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_by_origin_previous = RequestTotalByOriginMetric.from_dict(
+                _request_total_by_origin_previous
+            )
 
-        _request_total_per_code = d.pop("requestTotalPerCode", UNSET)
+        _request_total_per_code = d.pop(
+            "requestTotalPerCode", d.pop("request_total_per_code", UNSET)
+        )
         request_total_per_code: Union[Unset, ResourceMetricsRequestTotalPerCode]
         if isinstance(_request_total_per_code, Unset):
             request_total_per_code = UNSET
         else:
-            request_total_per_code = ResourceMetricsRequestTotalPerCode.from_dict(_request_total_per_code)
+            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 = d.pop(
+            "requestTotalPerCodePrevious", d.pop("request_total_per_code_previous", UNSET)
+        )
         request_total_per_code_previous: Union[Unset, ResourceMetricsRequestTotalPerCodePrevious]
         if isinstance(_request_total_per_code_previous, Unset):
             request_total_per_code_previous = UNSET
@@ -468,48 +519,52 @@ class ResourceMetrics:
                 _request_total_per_code_previous
             )
 
-        request_total_previous = d.pop("requestTotalPrevious", UNSET)
+        request_total_previous = d.pop(
+            "requestTotalPrevious", d.pop("request_total_previous", UNSET)
+        )
 
         rps = d.pop("rps", UNSET)
 
-        _rps_per_code = d.pop("rpsPerCode", UNSET)
+        _rps_per_code = d.pop("rpsPerCode", d.pop("rps_per_code", UNSET))
         rps_per_code: Union[Unset, ResourceMetricsRpsPerCode]
         if isinstance(_rps_per_code, Unset):
             rps_per_code = UNSET
         else:
             rps_per_code = ResourceMetricsRpsPerCode.from_dict(_rps_per_code)
 
-        _rps_per_code_previous = d.pop("rpsPerCodePrevious", UNSET)
+        _rps_per_code_previous = d.pop("rpsPerCodePrevious", d.pop("rps_per_code_previous", 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_per_code_previous = ResourceMetricsRpsPerCodePrevious.from_dict(
+                _rps_per_code_previous
+            )
 
-        rps_previous = d.pop("rpsPrevious", UNSET)
+        rps_previous = d.pop("rpsPrevious", d.pop("rps_previous", UNSET))
 
         sandboxes_cpu_usage = []
-        _sandboxes_cpu_usage = d.pop("sandboxesCpuUsage", UNSET)
+        _sandboxes_cpu_usage = d.pop("sandboxesCpuUsage", d.pop("sandboxes_cpu_usage", UNSET))
         for sandboxes_cpu_usage_item_data in _sandboxes_cpu_usage or []:
             sandboxes_cpu_usage_item = JobsChartValue.from_dict(sandboxes_cpu_usage_item_data)
 
             sandboxes_cpu_usage.append(sandboxes_cpu_usage_item)
 
         sandboxes_ram_usage = []
-        _sandboxes_ram_usage = d.pop("sandboxesRamUsage", UNSET)
+        _sandboxes_ram_usage = d.pop("sandboxesRamUsage", d.pop("sandboxes_ram_usage", UNSET))
         for sandboxes_ram_usage_item_data in _sandboxes_ram_usage or []:
             sandboxes_ram_usage_item = SandboxMetrics.from_dict(sandboxes_ram_usage_item_data)
 
             sandboxes_ram_usage.append(sandboxes_ram_usage_item)
 
-        _token_rate = d.pop("tokenRate", UNSET)
+        _token_rate = d.pop("tokenRate", d.pop("token_rate", UNSET))
         token_rate: Union[Unset, TokenRateMetrics]
         if isinstance(_token_rate, Unset):
             token_rate = UNSET
         else:
             token_rate = TokenRateMetrics.from_dict(_token_rate)
 
-        _token_total = d.pop("tokenTotal", UNSET)
+        _token_total = d.pop("tokenTotal", d.pop("token_total", UNSET))
         token_total: Union[Unset, TokenTotalMetric]
         if isinstance(_token_total, Unset):
             token_total = UNSET

blaxel/core/client/models/resource_metrics_request_total_per_code.py

@@ -19,7 +19,7 @@ class ResourceMetricsRequestTotalPerCode:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/resource_metrics_request_total_per_code_previous.py

@@ -19,7 +19,7 @@ class ResourceMetricsRequestTotalPerCodePrevious:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/resource_metrics_rps_per_code.py

@@ -19,7 +19,7 @@ class ResourceMetricsRpsPerCode:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/resource_metrics_rps_per_code_previous.py

@@ -19,7 +19,7 @@ class ResourceMetricsRpsPerCodePrevious:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()

blaxel/core/client/models/resource_trace.py

@@ -55,19 +55,19 @@ class ResourceTrace:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()
         duration = d.pop("duration", UNSET)
 
-        has_error = d.pop("hasError", UNSET)
+        has_error = d.pop("hasError", d.pop("has_error", UNSET))
 
-        start_time = d.pop("startTime", UNSET)
+        start_time = d.pop("startTime", d.pop("start_time", UNSET))
 
-        status_code = d.pop("statusCode", UNSET)
+        status_code = d.pop("statusCode", d.pop("status_code", UNSET))
 
-        trace_id = d.pop("traceID", UNSET)
+        trace_id = d.pop("traceID", d.pop("trace_id", UNSET))
 
         resource_trace = cls(
             duration=duration,

blaxel/core/client/models/revision_configuration.py

@@ -55,7 +55,7 @@ class RevisionConfiguration:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()
@@ -63,9 +63,9 @@ class RevisionConfiguration:
 
         canary = d.pop("canary", UNSET)
 
-        canary_percent = d.pop("canaryPercent", UNSET)
+        canary_percent = d.pop("canaryPercent", d.pop("canary_percent", UNSET))
 
-        sticky_session_ttl = d.pop("stickySessionTtl", UNSET)
+        sticky_session_ttl = d.pop("stickySessionTtl", d.pop("sticky_session_ttl", UNSET))
 
         traffic = d.pop("traffic", UNSET)
 

blaxel/core/client/models/revision_metadata.py

@@ -73,7 +73,7 @@ class RevisionMetadata:
         return field_dict
 
     @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
         if not src_dict:
             return None
         d = src_dict.copy()
@@ -81,17 +81,17 @@ class RevisionMetadata:
 
         canary = d.pop("canary", UNSET)
 
-        created_at = d.pop("createdAt", UNSET)
+        created_at = d.pop("createdAt", d.pop("created_at", UNSET))
 
-        created_by = d.pop("createdBy", UNSET)
+        created_by = d.pop("createdBy", d.pop("created_by", UNSET))
 
         id = d.pop("id", UNSET)
 
-        previous_active = d.pop("previousActive", UNSET)
+        previous_active = d.pop("previousActive", d.pop("previous_active", UNSET))
 
         status = d.pop("status", UNSET)
 
-        traffic_percent = d.pop("trafficPercent", UNSET)
+        traffic_percent = d.pop("trafficPercent", d.pop("traffic_percent", UNSET))
 
         revision_metadata = cls(
             active=active,