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

blaxel/core/client/models/pending_invitation_render.py

@@ -36,13 +36,16 @@ class PendingInvitationRender:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         email = self.email
 
         invited_at = self.invited_at
 
         invited_by: Union[Unset, dict[str, Any]] = UNSET
-        if self.invited_by and not isinstance(self.invited_by, Unset) and not isinstance(self.invited_by, dict):
+        if (
+            self.invited_by
+            and not isinstance(self.invited_by, Unset)
+            and not isinstance(self.invited_by, dict)
+        ):
             invited_by = self.invited_by.to_dict()
         elif self.invited_by and isinstance(self.invited_by, dict):
             invited_by = self.invited_by
@@ -50,7 +53,11 @@ class PendingInvitationRender:
         role = self.role
 
         workspace: Union[Unset, dict[str, Any]] = UNSET
-        if self.workspace and not isinstance(self.workspace, Unset) and not isinstance(self.workspace, dict):
+        if (
+            self.workspace
+            and not isinstance(self.workspace, Unset)
+            and not isinstance(self.workspace, dict)
+        ):
             workspace = self.workspace.to_dict()
         elif self.workspace and isinstance(self.workspace, dict):
             workspace = self.workspace
@@ -84,7 +91,7 @@ class PendingInvitationRender:
         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.pending_invitation_render_invited_by import PendingInvitationRenderInvitedBy
         from ..models.pending_invitation_render_workspace import PendingInvitationRenderWorkspace
         from ..models.pending_invitation_workspace_details import PendingInvitationWorkspaceDetails
@@ -94,9 +101,9 @@ class PendingInvitationRender:
         d = src_dict.copy()
         email = d.pop("email", UNSET)
 
-        invited_at = d.pop("invitedAt", UNSET)
+        invited_at = d.pop("invitedAt", d.pop("invited_at", UNSET))
 
-        _invited_by = d.pop("invitedBy", UNSET)
+        _invited_by = d.pop("invitedBy", d.pop("invited_by", UNSET))
         invited_by: Union[Unset, PendingInvitationRenderInvitedBy]
         if isinstance(_invited_by, Unset):
             invited_by = UNSET
@@ -112,7 +119,7 @@ class PendingInvitationRender:
         else:
             workspace = PendingInvitationRenderWorkspace.from_dict(_workspace)
 
-        _workspace_details = d.pop("workspaceDetails", UNSET)
+        _workspace_details = d.pop("workspaceDetails", d.pop("workspace_details", UNSET))
         workspace_details: Union[Unset, PendingInvitationWorkspaceDetails]
         if isinstance(_workspace_details, Unset):
             workspace_details = UNSET

blaxel/core/client/models/pending_invitation_render_invited_by.py

@@ -49,7 +49,7 @@ class PendingInvitationRenderInvitedBy:
         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/pending_invitation_render_workspace.py

@@ -37,11 +37,11 @@ class PendingInvitationRenderWorkspace:
         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()
-        display_name = d.pop("displayName", UNSET)
+        display_name = d.pop("displayName", d.pop("display_name", UNSET))
 
         name = d.pop("name", UNSET)
 

blaxel/core/client/models/pending_invitation_workspace_details.py

@@ -39,7 +39,7 @@ class PendingInvitationWorkspaceDetails:
         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/pod_template_spec.py

@@ -19,7 +19,7 @@ class PodTemplateSpec:
         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/policy.py

@@ -27,9 +27,12 @@ class Policy:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         metadata: Union[Unset, dict[str, Any]] = UNSET
-        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+        if (
+            self.metadata
+            and not isinstance(self.metadata, Unset)
+            and not isinstance(self.metadata, dict)
+        ):
             metadata = self.metadata.to_dict()
         elif self.metadata and isinstance(self.metadata, dict):
             metadata = self.metadata
@@ -51,7 +54,7 @@ class Policy:
         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.metadata import Metadata
         from ..models.policy_spec import PolicySpec
 

blaxel/core/client/models/policy_location.py

@@ -37,13 +37,13 @@ class PolicyLocation:
         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()
         name = d.pop("name", UNSET)
 
-        type_ = d.pop("type", UNSET)
+        type_ = d.pop("type", d.pop("type_", UNSET))
 
         policy_location = cls(
             name=name,

blaxel/core/client/models/policy_max_tokens.py

@@ -61,17 +61,19 @@ class PolicyMaxTokens:
         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()
         granularity = d.pop("granularity", UNSET)
 
-        input_ = d.pop("input", UNSET)
+        input_ = d.pop("input", d.pop("input_", UNSET))
 
         output = d.pop("output", UNSET)
 
-        ratio_input_over_output = d.pop("ratioInputOverOutput", UNSET)
+        ratio_input_over_output = d.pop(
+            "ratioInputOverOutput", d.pop("ratio_input_over_output", UNSET)
+        )
 
         step = d.pop("step", UNSET)
 

blaxel/core/client/models/policy_spec.py

@@ -38,7 +38,6 @@ class PolicySpec:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         flavors: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.flavors, Unset):
             flavors = []
@@ -54,13 +53,21 @@ class PolicySpec:
             locations = []
             for componentsschemas_policy_locations_item_data in self.locations:
                 if type(componentsschemas_policy_locations_item_data) is dict:
-                    componentsschemas_policy_locations_item = componentsschemas_policy_locations_item_data
+                    componentsschemas_policy_locations_item = (
+                        componentsschemas_policy_locations_item_data
+                    )
                 else:
-                    componentsschemas_policy_locations_item = componentsschemas_policy_locations_item_data.to_dict()
+                    componentsschemas_policy_locations_item = (
+                        componentsschemas_policy_locations_item_data.to_dict()
+                    )
                 locations.append(componentsschemas_policy_locations_item)
 
         max_tokens: Union[Unset, dict[str, Any]] = UNSET
-        if self.max_tokens and not isinstance(self.max_tokens, Unset) and not isinstance(self.max_tokens, dict):
+        if (
+            self.max_tokens
+            and not isinstance(self.max_tokens, Unset)
+            and not isinstance(self.max_tokens, dict)
+        ):
             max_tokens = self.max_tokens.to_dict()
         elif self.max_tokens and isinstance(self.max_tokens, dict):
             max_tokens = self.max_tokens
@@ -92,7 +99,7 @@ class PolicySpec:
         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.flavor import Flavor
         from ..models.policy_location import PolicyLocation
         from ..models.policy_max_tokens import PolicyMaxTokens
@@ -116,18 +123,18 @@ class PolicySpec:
 
             locations.append(componentsschemas_policy_locations_item)
 
-        _max_tokens = d.pop("maxTokens", UNSET)
+        _max_tokens = d.pop("maxTokens", d.pop("max_tokens", UNSET))
         max_tokens: Union[Unset, PolicyMaxTokens]
         if isinstance(_max_tokens, Unset):
             max_tokens = UNSET
         else:
             max_tokens = PolicyMaxTokens.from_dict(_max_tokens)
 
-        resource_types = cast(list[str], d.pop("resourceTypes", UNSET))
+        resource_types = cast(list[str], d.pop("resourceTypes", d.pop("resource_types", UNSET)))
 
         sandbox = d.pop("sandbox", UNSET)
 
-        type_ = d.pop("type", UNSET)
+        type_ = d.pop("type", d.pop("type_", UNSET))
 
         policy_spec = cls(
             flavors=flavors,

blaxel/core/client/models/port.py

@@ -43,7 +43,7 @@ class Port:
         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/preview.py

@@ -27,9 +27,12 @@ class Preview:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         metadata: Union[Unset, dict[str, Any]] = UNSET
-        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+        if (
+            self.metadata
+            and not isinstance(self.metadata, Unset)
+            and not isinstance(self.metadata, dict)
+        ):
             metadata = self.metadata.to_dict()
         elif self.metadata and isinstance(self.metadata, dict):
             metadata = self.metadata
@@ -51,7 +54,7 @@ class Preview:
         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.preview_metadata import PreviewMetadata
         from ..models.preview_spec import PreviewSpec
 

blaxel/core/client/models/preview_metadata.py

@@ -79,25 +79,25 @@ class PreviewMetadata:
         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()
-        created_at = d.pop("createdAt", UNSET)
+        created_at = d.pop("createdAt", d.pop("created_at", UNSET))
 
-        updated_at = d.pop("updatedAt", UNSET)
+        updated_at = d.pop("updatedAt", d.pop("updated_at", UNSET))
 
-        created_by = d.pop("createdBy", UNSET)
+        created_by = d.pop("createdBy", d.pop("created_by", UNSET))
 
-        updated_by = d.pop("updatedBy", UNSET)
+        updated_by = d.pop("updatedBy", d.pop("updated_by", UNSET))
 
-        display_name = d.pop("displayName", UNSET)
+        display_name = d.pop("displayName", d.pop("display_name", UNSET))
 
         name = d.pop("name", UNSET)
 
-        resource_name = d.pop("resourceName", UNSET)
+        resource_name = d.pop("resourceName", d.pop("resource_name", UNSET))
 
-        resource_type = d.pop("resourceType", UNSET)
+        resource_type = d.pop("resourceType", d.pop("resource_type", UNSET))
 
         workspace = d.pop("workspace", UNSET)
 

blaxel/core/client/models/preview_spec.py

@@ -46,7 +46,6 @@ class PreviewSpec:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         custom_domain = self.custom_domain
 
         expires = self.expires
@@ -110,33 +109,33 @@ class PreviewSpec:
         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.preview_spec_request_headers import PreviewSpecRequestHeaders
         from ..models.preview_spec_response_headers import PreviewSpecResponseHeaders
 
         if not src_dict:
             return None
         d = src_dict.copy()
-        custom_domain = d.pop("customDomain", UNSET)
+        custom_domain = d.pop("customDomain", d.pop("custom_domain", UNSET))
 
         expires = d.pop("expires", UNSET)
 
         port = d.pop("port", UNSET)
 
-        prefix_url = d.pop("prefixUrl", UNSET)
+        prefix_url = d.pop("prefixUrl", d.pop("prefix_url", UNSET))
 
         public = d.pop("public", UNSET)
 
         region = d.pop("region", UNSET)
 
-        _request_headers = d.pop("requestHeaders", UNSET)
+        _request_headers = d.pop("requestHeaders", d.pop("request_headers", 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 = d.pop("responseHeaders", d.pop("response_headers", UNSET))
         response_headers: Union[Unset, PreviewSpecResponseHeaders]
         if isinstance(_response_headers, Unset):
             response_headers = UNSET

blaxel/core/client/models/preview_spec_request_headers.py

@@ -22,7 +22,7 @@ class PreviewSpecRequestHeaders:
         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/preview_spec_response_headers.py

@@ -19,7 +19,7 @@ class PreviewSpecResponseHeaders:
         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/preview_token.py

@@ -27,9 +27,12 @@ class PreviewToken:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         metadata: Union[Unset, dict[str, Any]] = UNSET
-        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+        if (
+            self.metadata
+            and not isinstance(self.metadata, Unset)
+            and not isinstance(self.metadata, dict)
+        ):
             metadata = self.metadata.to_dict()
         elif self.metadata and isinstance(self.metadata, dict):
             metadata = self.metadata
@@ -51,7 +54,7 @@ class PreviewToken:
         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.preview_token_metadata import PreviewTokenMetadata
         from ..models.preview_token_spec import PreviewTokenSpec
 

blaxel/core/client/models/preview_token_metadata.py

@@ -55,17 +55,17 @@ class PreviewTokenMetadata:
         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()
         name = d.pop("name", UNSET)
 
-        preview_name = d.pop("previewName", UNSET)
+        preview_name = d.pop("previewName", d.pop("preview_name", UNSET))
 
-        resource_name = d.pop("resourceName", UNSET)
+        resource_name = d.pop("resourceName", d.pop("resource_name", UNSET))
 
-        resource_type = d.pop("resourceType", UNSET)
+        resource_type = d.pop("resourceType", d.pop("resource_type", UNSET))
 
         workspace = d.pop("workspace", UNSET)
 

blaxel/core/client/models/preview_token_spec.py

@@ -43,13 +43,13 @@ class PreviewTokenSpec:
         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()
         expired = d.pop("expired", UNSET)
 
-        expires_at = d.pop("expiresAt", UNSET)
+        expires_at = d.pop("expiresAt", d.pop("expires_at", UNSET))
 
         token = d.pop("token", UNSET)
 

blaxel/core/client/models/private_location.py

@@ -31,7 +31,7 @@ class PrivateLocation:
         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/public_ip.py

@@ -46,15 +46,15 @@ class PublicIp:
         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()
         description = d.pop("description", UNSET)
 
-        ipv_4_cidrs = cast(list[str], d.pop("ipv4Cidrs", UNSET))
+        ipv_4_cidrs = cast(list[str], d.pop("ipv4Cidrs", d.pop("ipv_4_cidrs", UNSET)))
 
-        ipv_6_cidrs = cast(list[str], d.pop("ipv6Cidrs", UNSET))
+        ipv_6_cidrs = cast(list[str], d.pop("ipv6Cidrs", d.pop("ipv_6_cidrs", UNSET)))
 
         public_ip = cls(
             description=description,

blaxel/core/client/models/public_ips.py

@@ -17,7 +17,6 @@ class PublicIps:
     additional_properties: dict[str, "PublicIp"] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
             if type(prop) is dict:
@@ -28,7 +27,7 @@ class PublicIps:
         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.public_ip import PublicIp
 
         if not src_dict:

blaxel/core/client/models/region.py

@@ -61,7 +61,7 @@ class Region:
         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()
@@ -71,7 +71,7 @@ class Region:
 
         country = d.pop("country", UNSET)
 
-        info_generation = d.pop("infoGeneration", UNSET)
+        info_generation = d.pop("infoGeneration", d.pop("info_generation", UNSET))
 
         location = d.pop("location", UNSET)
 

blaxel/core/client/models/repository.py

@@ -37,11 +37,11 @@ class Repository:
         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()
-        type_ = d.pop("type", UNSET)
+        type_ = d.pop("type", d.pop("type_", UNSET))
 
         url = d.pop("url", UNSET)
 

blaxel/core/client/models/request_duration_over_time_metric.py

@@ -55,7 +55,7 @@ class RequestDurationOverTimeMetric:
         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_duration_over_time_metrics.py

@@ -24,7 +24,6 @@ class RequestDurationOverTimeMetrics:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         request_duration_over_time: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.request_duration_over_time, Unset):
             request_duration_over_time = []
@@ -44,14 +43,16 @@ class RequestDurationOverTimeMetrics:
         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_duration_over_time_metric import RequestDurationOverTimeMetric
 
         if not src_dict:
             return None
         d = src_dict.copy()
         request_duration_over_time = []
-        _request_duration_over_time = d.pop("requestDurationOverTime", UNSET)
+        _request_duration_over_time = d.pop(
+            "requestDurationOverTime", d.pop("request_duration_over_time", UNSET)
+        )
         for request_duration_over_time_item_data in _request_duration_over_time or []:
             request_duration_over_time_item = RequestDurationOverTimeMetric.from_dict(
                 request_duration_over_time_item_data

blaxel/core/client/models/request_total_by_origin_metric.py

@@ -28,11 +28,12 @@ class RequestTotalByOriginMetric:
     """
 
     request_total_by_origin: Union[Unset, "RequestTotalByOriginMetricRequestTotalByOrigin"] = UNSET
-    request_total_by_origin_and_code: Union[Unset, "RequestTotalByOriginMetricRequestTotalByOriginAndCode"] = UNSET
+    request_total_by_origin_and_code: Union[
+        Unset, "RequestTotalByOriginMetricRequestTotalByOriginAndCode"
+    ] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-
         request_total_by_origin: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.request_total_by_origin
@@ -50,7 +51,9 @@ class RequestTotalByOriginMetric:
             and not isinstance(self.request_total_by_origin_and_code, dict)
         ):
             request_total_by_origin_and_code = self.request_total_by_origin_and_code.to_dict()
-        elif self.request_total_by_origin_and_code and isinstance(self.request_total_by_origin_and_code, dict):
+        elif self.request_total_by_origin_and_code and isinstance(
+            self.request_total_by_origin_and_code, dict
+        ):
             request_total_by_origin_and_code = self.request_total_by_origin_and_code
 
         field_dict: dict[str, Any] = {}
@@ -64,7 +67,7 @@ class RequestTotalByOriginMetric:
         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_by_origin_metric_request_total_by_origin import (
             RequestTotalByOriginMetricRequestTotalByOrigin,
         )
@@ -75,20 +78,30 @@ class RequestTotalByOriginMetric:
         if not src_dict:
             return None
         d = src_dict.copy()
-        _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, RequestTotalByOriginMetricRequestTotalByOrigin]
         if isinstance(_request_total_by_origin, Unset):
             request_total_by_origin = UNSET
         else:
-            request_total_by_origin = RequestTotalByOriginMetricRequestTotalByOrigin.from_dict(_request_total_by_origin)
+            request_total_by_origin = RequestTotalByOriginMetricRequestTotalByOrigin.from_dict(
+                _request_total_by_origin
+            )
 
-        _request_total_by_origin_and_code = d.pop("requestTotalByOriginAndCode", UNSET)
-        request_total_by_origin_and_code: Union[Unset, RequestTotalByOriginMetricRequestTotalByOriginAndCode]
+        _request_total_by_origin_and_code = d.pop(
+            "requestTotalByOriginAndCode", d.pop("request_total_by_origin_and_code", UNSET)
+        )
+        request_total_by_origin_and_code: Union[
+            Unset, RequestTotalByOriginMetricRequestTotalByOriginAndCode
+        ]
         if isinstance(_request_total_by_origin_and_code, Unset):
             request_total_by_origin_and_code = UNSET
         else:
-            request_total_by_origin_and_code = RequestTotalByOriginMetricRequestTotalByOriginAndCode.from_dict(
-                _request_total_by_origin_and_code
+            request_total_by_origin_and_code = (
+                RequestTotalByOriginMetricRequestTotalByOriginAndCode.from_dict(
+                    _request_total_by_origin_and_code
+                )
             )
 
         request_total_by_origin_metric = cls(

blaxel/core/client/models/request_total_by_origin_metric_request_total_by_origin.py

@@ -19,7 +19,7 @@ class RequestTotalByOriginMetricRequestTotalByOrigin:
         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_by_origin_metric_request_total_by_origin_and_code.py

@@ -19,7 +19,7 @@ class RequestTotalByOriginMetricRequestTotalByOriginAndCode:
         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()