beamlit 0.0.20rc3__py3-none-any.whl → 0.0.20rc5__py3-none-any.whl

beamlit/authentication/authentication.py

@@ -1,12 +1,13 @@
 from dataclasses import dataclass
-from typing import Generator
+from typing import Dict, Generator
 
+from beamlit.common.settings import Settings
 from httpx import Auth, Request, Response
 
 from ..client import AuthenticatedClient
 from .apikey import ApiKeyProvider
 from .clientcredentials import ClientCredentials
-from .credentials import Credentials
+from .credentials import Credentials, load_credentials_from_settings
 from .device_mode import BearerToken
 
 
@@ -24,6 +25,15 @@ class RunClientWithCredentials:
     run_url: str = "https://run.beamlit.dev/v0"
 
 
+def new_client_from_settings(settings: Settings):
+    credentials = load_credentials_from_settings(settings)
+
+    client_config = RunClientWithCredentials(
+        credentials=credentials,
+        workspace=settings.workspace,
+    )
+    return new_client_with_credentials(client_config)
+
 def new_client_with_credentials(config: RunClientWithCredentials):
     provider: Auth = None
     if config.credentials.api_key:
@@ -36,3 +46,22 @@ def new_client_with_credentials(config: RunClientWithCredentials):
         provider = PublicProvider()
 
     return AuthenticatedClient(base_url=config.api_url, provider=provider)
+
+def get_authentication_headers(settings: Settings) -> Dict[str, str]:
+    credentials = load_credentials_from_settings(settings)
+    config = RunClientWithCredentials(
+        credentials=credentials,
+        workspace=settings.workspace,
+    )
+    provider = None
+    if config.credentials.api_key:
+        provider = ApiKeyProvider(config.credentials, config.workspace)
+    elif config.credentials.access_token:
+        provider = BearerToken(config.credentials, config.workspace, config.api_url)
+    elif config.credentials.client_credentials:
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
+
+    if provider is None:
+        return None
+
+    return provider.get_headers()

beamlit/authentication/clientcredentials.py

@@ -23,7 +23,27 @@ class ClientCredentials(Auth):
         self.workspace_name = workspace_name
         self.base_url = base_url
 
+    def get_headers(self):
+        err = self.refresh_if_needed()
+        if err:
+            raise err
+
+        return {
+            'X-Beamlit-Authorization': f'Bearer {self.credentials.access_token}',
+            'X-Beamlit-Workspace': self.workspace_name
+        }
+
     def refresh_if_needed(self) -> Optional[Exception]:
+        settings = get_settings()
+        if self.credentials.client_credentials and not self.credentials.refresh_token:
+            headers = { "Authorization": f"Basic {self.credentials.client_credentials}" }
+            body = { "grant_type": "client_credentials" }
+            response = requests.post(f"{settings.base_url}/oauth/token", headers=headers, json=body)
+            response.raise_for_status()
+            self.credentials.access_token = response.json()['access_token']
+            self.credentials.refresh_token = response.json()['refresh_token']
+            self.credentials.expires_in = response.json()['expires_in']
+
         # Need to refresh token if expires in less than 10 minutes
         parts = self.credentials.access_token.split('.')
         if len(parts) != 3:
@@ -42,15 +62,6 @@ class ClientCredentials(Auth):
         return None
 
     def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
-        settings = get_settings()
-        if self.credentials.client_credentials and not self.credentials.refresh_token:
-            headers = { "Authorization": f"Basic {self.credentials.client_credentials}" }
-            body = { "grant_type": "client_credentials" }
-            response = requests.post(f"{settings.base_url}/oauth/token", headers=headers, json=body)
-            response.raise_for_status()
-            self.credentials.access_token = response.json()['access_token']
-            self.credentials.refresh_token = response.json()['refresh_token']
-            self.credentials.expires_in = response.json()['expires_in']
         err = self.refresh_if_needed()
         if err:
             return err

beamlit/authentication/credentials.py

@@ -14,6 +14,7 @@ class Credentials:
     expires_in: int = 0
     device_code: str = ""
     client_credentials: str = ""
+
 @dataclass
 class WorkspaceConfig:
     name: str

beamlit/authentication/device_mode.py

@@ -2,7 +2,7 @@ import base64
 import json
 import time
 from dataclasses import dataclass
-from typing import Generator, Optional
+from typing import Dict, Generator, Optional
 
 from httpx import Auth, Request, Response, post
 
@@ -45,6 +45,15 @@ class BearerToken(Auth):
         self.workspace_name = workspace_name
         self.base_url = base_url
 
+    def get_headers(self) -> Dict[str, str]:
+        err = self.refresh_if_needed()
+        if err:
+            raise err
+        return {
+            'X-Beamlit-Authorization': f'Bearer {self.credentials.access_token}',
+            'X-Beamlit-Workspace': self.workspace_name
+        }
+
     def refresh_if_needed(self) -> Optional[Exception]:
         # Need to refresh token if expires in less than 10 minutes
         parts = self.credentials.access_token.split('.')

beamlit/common/generate.py

@@ -13,8 +13,13 @@ def generate_kit_function_code(settings: Settings, function: FunctionDeployment,
     export_code = ""
     code = ""
     for kit in kit:
-        body = {"function": kit.name, "workspace": settings.workspace, **kit.to_dict()}
-        new_code, export = generate_function_code(body, force_name_in_endpoint=function.function, kit=True)
+        fn = FunctionDeployment(
+            function=kit.name,
+            workspace=settings.workspace,
+            parameters=kit.parameters,
+            description=kit.description,
+        )
+        new_code, export = generate_function_code(settings, fn, force_name_in_endpoint=function.function, kit=True)
         code += new_code
         export_code += export
     return code, export_code
@@ -141,7 +146,7 @@ run_client = RunClient(client=client)
     if settings.agent_functions and len(settings.agent_functions) > 0:
         for function_config in settings.agent_functions:
             if function_config.kit and len(function_config.kit) > 0:
-                new_code, export = generate_kit_function_code(settings, function_config)
+                new_code, export = generate_kit_function_code(settings, function_config, function_config.kit)
                 code += new_code
                 export_code += export
             else:

beamlit/common/logger.py

@@ -19,6 +19,8 @@ class ColoredFormatter(logging.Formatter):
 def init(log_level: str):
     logging.getLogger("uvicorn.access").handlers.clear()
     logging.getLogger("uvicorn.access").propagate = False
+    logging.getLogger("uvicorn.error").handlers.clear()
+    logging.getLogger("uvicorn.error").propagate = False
     logging.getLogger("httpx").handlers.clear()
     logging.getLogger("httpx").propagate = False
 

beamlit/common/settings.py

@@ -54,7 +54,7 @@ class Settings(BaseSettings):
     ) -> Tuple[PydanticBaseSettingsSource, ...]:
         return (env_settings, dotenv_settings, file_secret_settings, YamlConfigSettingsSource(settings_cls), init_settings, )
 
-def init_agent(client: AuthenticatedClient):
+def init_agent(client: AuthenticatedClient, destination: str = f"{os.getcwd()}/src/beamlit_generated.py"):
     from beamlit.api.agents import get_agent_deployment
     from beamlit.common.generate import generate
 
@@ -89,10 +89,6 @@ def init_agent(client: AuthenticatedClient):
         model_deployment = get_model_deployment.sync(agent_deployment.model, env , client=client)
         SETTINGS.agent_model = model_deployment
 
-
-    destination = f"{os.getcwd()}/src/beamlit_generated.py"
-
-
     content_generate = generate(destination, dry_run=True)
     compared_content = None
     if os.path.exists(destination):

beamlit/models/__init__.py

@@ -5,10 +5,10 @@ from .agent import Agent
 from .agent_chain import AgentChain
 from .agent_configuration import AgentConfiguration
 from .agent_deployment import AgentDeployment
-from .agent_deployment_configuration_type_0 import AgentDeploymentConfigurationType0
+from .agent_deployment_configuration import AgentDeploymentConfiguration
 from .agent_deployment_history import AgentDeploymentHistory
 from .agent_deployment_history_event import AgentDeploymentHistoryEvent
-from .agent_deployment_pod_template_type_0 import AgentDeploymentPodTemplateType0
+from .agent_deployment_pod_template import AgentDeploymentPodTemplate
 from .agent_release import AgentRelease
 from .agent_with_deployments import AgentWithDeployments
 from .api_key import ApiKey
@@ -23,15 +23,15 @@ from .create_workspace_service_account_response_200 import CreateWorkspaceServic
 from .delete_workspace_service_account_response_200 import DeleteWorkspaceServiceAccountResponse200
 from .deployment_configuration import DeploymentConfiguration
 from .deployment_configurations import DeploymentConfigurations
-from .deployment_serverless_config_type_0 import DeploymentServerlessConfigType0
+from .deployment_serverless_config import DeploymentServerlessConfig
 from .environment import Environment
 from .environment_metrics import EnvironmentMetrics
 from .flavor import Flavor
 from .function import Function
 from .function_configuration import FunctionConfiguration
 from .function_deployment import FunctionDeployment
-from .function_deployment_configuration_type_0 import FunctionDeploymentConfigurationType0
-from .function_deployment_pod_template_type_0 import FunctionDeploymentPodTemplateType0
+from .function_deployment_configuration import FunctionDeploymentConfiguration
+from .function_deployment_pod_template import FunctionDeploymentPodTemplate
 from .function_kit import FunctionKit
 from .function_provider_ref import FunctionProviderRef
 from .function_release import FunctionRelease
@@ -59,7 +59,7 @@ from .model_deployment_metrics_inference_per_second_per_region import ModelDeplo
 from .model_deployment_metrics_query_per_second_per_region_per_code import (
     ModelDeploymentMetricsQueryPerSecondPerRegionPerCode,
 )
-from .model_deployment_pod_template_type_0 import ModelDeploymentPodTemplateType0
+from .model_deployment_pod_template import ModelDeploymentPodTemplate
 from .model_metrics import ModelMetrics
 from .model_provider import ModelProvider
 from .model_provider_ref import ModelProviderRef
@@ -77,31 +77,29 @@ from .provider_config import ProviderConfig
 from .qps import QPS
 from .resource_deployment_log import ResourceDeploymentLog
 from .resource_deployment_metrics import ResourceDeploymentMetrics
-from .resource_deployment_metrics_inference_per_region_type_0 import ResourceDeploymentMetricsInferencePerRegionType0
-from .resource_deployment_metrics_inference_per_second_per_region_type_0 import (
-    ResourceDeploymentMetricsInferencePerSecondPerRegionType0,
+from .resource_deployment_metrics_inference_per_region import ResourceDeploymentMetricsInferencePerRegion
+from .resource_deployment_metrics_inference_per_second_per_region import (
+    ResourceDeploymentMetricsInferencePerSecondPerRegion,
 )
-from .resource_deployment_metrics_query_per_region_per_code_type_0 import (
-    ResourceDeploymentMetricsQueryPerRegionPerCodeType0,
-)
-from .resource_deployment_metrics_query_per_second_per_region_per_code_type_0 import (
-    ResourceDeploymentMetricsQueryPerSecondPerRegionPerCodeType0,
+from .resource_deployment_metrics_query_per_region_per_code import ResourceDeploymentMetricsQueryPerRegionPerCode
+from .resource_deployment_metrics_query_per_second_per_region_per_code import (
+    ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode,
 )
 from .resource_metrics import ResourceMetrics
 from .runtime import Runtime
-from .runtime_readiness_probe_type_0 import RuntimeReadinessProbeType0
+from .runtime_readiness_probe import RuntimeReadinessProbe
 from .runtime_resources import RuntimeResources
 from .serverless_config import ServerlessConfig
 from .standard_fields_dynamo_db import StandardFieldsDynamoDb
 from .store_agent import StoreAgent
 from .store_agent_configuration import StoreAgentConfiguration
-from .store_agent_labels_type_0 import StoreAgentLabelsType0
+from .store_agent_labels import StoreAgentLabels
 from .store_configuration import StoreConfiguration
 from .store_configuration_option import StoreConfigurationOption
 from .store_function import StoreFunction
 from .store_function_configuration import StoreFunctionConfiguration
 from .store_function_kit import StoreFunctionKit
-from .store_function_labels_type_0 import StoreFunctionLabelsType0
+from .store_function_labels import StoreFunctionLabels
 from .store_function_parameter import StoreFunctionParameter
 from .update_workspace_service_account_body import UpdateWorkspaceServiceAccountBody
 from .update_workspace_service_account_response_200 import UpdateWorkspaceServiceAccountResponse200
@@ -116,10 +114,10 @@ __all__ = (
     "AgentChain",
     "AgentConfiguration",
     "AgentDeployment",
-    "AgentDeploymentConfigurationType0",
+    "AgentDeploymentConfiguration",
     "AgentDeploymentHistory",
     "AgentDeploymentHistoryEvent",
-    "AgentDeploymentPodTemplateType0",
+    "AgentDeploymentPodTemplate",
     "AgentRelease",
     "AgentWithDeployments",
     "ApiKey",
@@ -134,15 +132,15 @@ __all__ = (
     "DeleteWorkspaceServiceAccountResponse200",
     "DeploymentConfiguration",
     "DeploymentConfigurations",
-    "DeploymentServerlessConfigType0",
+    "DeploymentServerlessConfig",
     "Environment",
     "EnvironmentMetrics",
     "Flavor",
     "Function",
     "FunctionConfiguration",
     "FunctionDeployment",
-    "FunctionDeploymentConfigurationType0",
-    "FunctionDeploymentPodTemplateType0",
+    "FunctionDeploymentConfiguration",
+    "FunctionDeploymentPodTemplate",
     "FunctionKit",
     "FunctionProviderRef",
     "FunctionRelease",
@@ -168,7 +166,7 @@ __all__ = (
     "ModelDeploymentMetrics",
     "ModelDeploymentMetricsInferencePerSecondPerRegion",
     "ModelDeploymentMetricsQueryPerSecondPerRegionPerCode",
-    "ModelDeploymentPodTemplateType0",
+    "ModelDeploymentPodTemplate",
     "ModelMetrics",
     "ModelProvider",
     "ModelProviderRef",
@@ -186,25 +184,25 @@ __all__ = (
     "QPS",
     "ResourceDeploymentLog",
     "ResourceDeploymentMetrics",
-    "ResourceDeploymentMetricsInferencePerRegionType0",
-    "ResourceDeploymentMetricsInferencePerSecondPerRegionType0",
-    "ResourceDeploymentMetricsQueryPerRegionPerCodeType0",
-    "ResourceDeploymentMetricsQueryPerSecondPerRegionPerCodeType0",
+    "ResourceDeploymentMetricsInferencePerRegion",
+    "ResourceDeploymentMetricsInferencePerSecondPerRegion",
+    "ResourceDeploymentMetricsQueryPerRegionPerCode",
+    "ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode",
     "ResourceMetrics",
     "Runtime",
-    "RuntimeReadinessProbeType0",
+    "RuntimeReadinessProbe",
     "RuntimeResources",
     "ServerlessConfig",
     "StandardFieldsDynamoDb",
     "StoreAgent",
     "StoreAgentConfiguration",
-    "StoreAgentLabelsType0",
+    "StoreAgentLabels",
     "StoreConfiguration",
     "StoreConfigurationOption",
     "StoreFunction",
     "StoreFunctionConfiguration",
     "StoreFunctionKit",
-    "StoreFunctionLabelsType0",
+    "StoreFunctionLabels",
     "StoreFunctionParameter",
     "UpdateWorkspaceServiceAccountBody",
     "UpdateWorkspaceServiceAccountResponse200",

beamlit/models/acl.py

@@ -92,6 +92,8 @@ class ACL:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         created_at = d.pop("created_at", UNSET)
 

beamlit/models/agent.py

@@ -88,6 +88,8 @@ class Agent:
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         from ..models.labels_type_0 import LabelsType0
 
+        if not src_dict:
+            return None
         d = src_dict.copy()
         created_at = d.pop("created_at", UNSET)
 

beamlit/models/agent_chain.py

@@ -44,6 +44,8 @@ class AgentChain:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         description = d.pop("description", UNSET)
 

beamlit/models/agent_configuration.py

@@ -38,6 +38,8 @@ class AgentConfiguration:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         secret = d.pop("secret", UNSET)
 

beamlit/models/agent_deployment.py

@@ -7,9 +7,9 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.agent_chain import AgentChain
-    from ..models.agent_deployment_configuration_type_0 import AgentDeploymentConfigurationType0
-    from ..models.agent_deployment_pod_template_type_0 import AgentDeploymentPodTemplateType0
-    from ..models.deployment_serverless_config_type_0 import DeploymentServerlessConfigType0
+    from ..models.agent_deployment_configuration import AgentDeploymentConfiguration
+    from ..models.agent_deployment_pod_template import AgentDeploymentPodTemplate
+    from ..models.deployment_serverless_config import DeploymentServerlessConfig
     from ..models.flavor import Flavor
     from ..models.labels_type_0 import LabelsType0
     from ..models.runtime import Runtime
@@ -29,11 +29,11 @@ class AgentDeployment:
         updated_by (Union[Unset, str]): The user or service account who updated the resource
         agent (Union[Unset, str]): The name of the agent
         agent_chain (Union[Unset, List['AgentChain']]): Agent chaining configuration
-        configuration (Union['AgentDeploymentConfigurationType0', None, Unset]): Agent configuration, this is a key
-            value storage. In your agent you can retrieve the value with config[key]
+        configuration (Union[Unset, AgentDeploymentConfiguration]): Agent configuration, this is a key value storage. In
+            your agent you can retrieve the value with config[key]
         description (Union[Unset, str]): Agent description, very important to have a clear description for your agent if
             you want to make it work with agent chaining
-        enabled (Union[None, Unset, bool]): Whether the agent deployment is enabled
+        enabled (Union[Unset, bool]): Whether the agent deployment is enabled
         environment (Union[Unset, str]): The name of the environment
         flavors (Union[Unset, List['Flavor']]): Types of hardware available for deployments
         functions (Union[Unset, List[str]]): Functions used by the agent, those functions needs to be created before
@@ -41,12 +41,11 @@ class AgentDeployment:
         integration_connections (Union[Unset, List[str]]):
         labels (Union['LabelsType0', None, Unset]): Labels
         model (Union[Unset, str]): Model beamlit to use for agent, it should be compatible with function calling
-        pod_template (Union['AgentDeploymentPodTemplateType0', None, Unset]): The pod template, should be a valid
-            Kubernetes pod template
+        pod_template (Union[Unset, AgentDeploymentPodTemplate]): The pod template, should be a valid Kubernetes pod
+            template
         policies (Union[Unset, List[str]]):
         runtime (Union[Unset, Runtime]): Set of configurations for a deployment
-        serverless_config (Union['DeploymentServerlessConfigType0', None, Unset]): Configuration for a serverless
-            deployment
+        serverless_config (Union[Unset, DeploymentServerlessConfig]): Configuration for a serverless deployment
         store_id (Union[Unset, str]): Create from a store registered function
         workspace (Union[Unset, str]): The workspace the agent deployment belongs to
     """
@@ -57,27 +56,24 @@ class AgentDeployment:
     updated_by: Union[Unset, str] = UNSET
     agent: Union[Unset, str] = UNSET
     agent_chain: Union[Unset, List["AgentChain"]] = UNSET
-    configuration: Union["AgentDeploymentConfigurationType0", None, Unset] = UNSET
+    configuration: Union[Unset, "AgentDeploymentConfiguration"] = UNSET
     description: Union[Unset, str] = UNSET
-    enabled: Union[None, Unset, bool] = UNSET
+    enabled: Union[Unset, bool] = UNSET
     environment: Union[Unset, str] = UNSET
     flavors: Union[Unset, List["Flavor"]] = UNSET
     functions: Union[Unset, List[str]] = UNSET
     integration_connections: Union[Unset, List[str]] = UNSET
     labels: Union["LabelsType0", None, Unset] = UNSET
     model: Union[Unset, str] = UNSET
-    pod_template: Union["AgentDeploymentPodTemplateType0", None, Unset] = UNSET
+    pod_template: Union[Unset, "AgentDeploymentPodTemplate"] = UNSET
     policies: Union[Unset, List[str]] = UNSET
     runtime: Union[Unset, "Runtime"] = UNSET
-    serverless_config: Union["DeploymentServerlessConfigType0", None, Unset] = UNSET
+    serverless_config: Union[Unset, "DeploymentServerlessConfig"] = UNSET
     store_id: Union[Unset, str] = UNSET
     workspace: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        from ..models.agent_deployment_configuration_type_0 import AgentDeploymentConfigurationType0
-        from ..models.agent_deployment_pod_template_type_0 import AgentDeploymentPodTemplateType0
-        from ..models.deployment_serverless_config_type_0 import DeploymentServerlessConfigType0
         from ..models.labels_type_0 import LabelsType0
 
         created_at = self.created_at
@@ -97,21 +93,13 @@ class AgentDeployment:
                 agent_chain_item = agent_chain_item_data.to_dict()
                 agent_chain.append(agent_chain_item)
 
-        configuration: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.configuration, Unset):
-            configuration = UNSET
-        elif isinstance(self.configuration, AgentDeploymentConfigurationType0):
+        configuration: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.configuration, Unset):
             configuration = self.configuration.to_dict()
-        else:
-            configuration = self.configuration
 
         description = self.description
 
-        enabled: Union[None, Unset, bool]
-        if isinstance(self.enabled, Unset):
-            enabled = UNSET
-        else:
-            enabled = self.enabled
+        enabled = self.enabled
 
         environment = self.environment
 
@@ -140,13 +128,9 @@ class AgentDeployment:
 
         model = self.model
 
-        pod_template: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.pod_template, Unset):
-            pod_template = UNSET
-        elif isinstance(self.pod_template, AgentDeploymentPodTemplateType0):
+        pod_template: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.pod_template, Unset):
             pod_template = self.pod_template.to_dict()
-        else:
-            pod_template = self.pod_template
 
         policies: Union[Unset, List[str]] = UNSET
         if not isinstance(self.policies, Unset):
@@ -156,13 +140,9 @@ class AgentDeployment:
         if not isinstance(self.runtime, Unset):
             runtime = self.runtime.to_dict()
 
-        serverless_config: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.serverless_config, Unset):
-            serverless_config = UNSET
-        elif isinstance(self.serverless_config, DeploymentServerlessConfigType0):
+        serverless_config: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.serverless_config, Unset):
             serverless_config = self.serverless_config.to_dict()
-        else:
-            serverless_config = self.serverless_config
 
         store_id = self.store_id
 
@@ -219,13 +199,15 @@ class AgentDeployment:
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         from ..models.agent_chain import AgentChain
-        from ..models.agent_deployment_configuration_type_0 import AgentDeploymentConfigurationType0
-        from ..models.agent_deployment_pod_template_type_0 import AgentDeploymentPodTemplateType0
-        from ..models.deployment_serverless_config_type_0 import DeploymentServerlessConfigType0
+        from ..models.agent_deployment_configuration import AgentDeploymentConfiguration
+        from ..models.agent_deployment_pod_template import AgentDeploymentPodTemplate
+        from ..models.deployment_serverless_config import DeploymentServerlessConfig
         from ..models.flavor import Flavor
         from ..models.labels_type_0 import LabelsType0
         from ..models.runtime import Runtime
 
+        if not src_dict:
+            return None
         d = src_dict.copy()
         created_at = d.pop("created_at", UNSET)
 
@@ -244,33 +226,16 @@ class AgentDeployment:
 
             agent_chain.append(agent_chain_item)
 
-        def _parse_configuration(data: object) -> Union["AgentDeploymentConfigurationType0", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                configuration_type_0 = AgentDeploymentConfigurationType0.from_dict(data)
-
-                return configuration_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["AgentDeploymentConfigurationType0", None, Unset], data)
-
-        configuration = _parse_configuration(d.pop("configuration", UNSET))
+        _configuration = d.pop("configuration", UNSET)
+        configuration: Union[Unset, AgentDeploymentConfiguration]
+        if isinstance(_configuration, Unset):
+            configuration = UNSET
+        else:
+            configuration = AgentDeploymentConfiguration.from_dict(_configuration)
 
         description = d.pop("description", UNSET)
 
-        def _parse_enabled(data: object) -> Union[None, Unset, bool]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, bool], data)
-
-        enabled = _parse_enabled(d.pop("enabled", UNSET))
+        enabled = d.pop("enabled", UNSET)
 
         environment = d.pop("environment", UNSET)
 
@@ -304,22 +269,12 @@ class AgentDeployment:
 
         model = d.pop("model", UNSET)
 
-        def _parse_pod_template(data: object) -> Union["AgentDeploymentPodTemplateType0", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                pod_template_type_0 = AgentDeploymentPodTemplateType0.from_dict(data)
-
-                return pod_template_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["AgentDeploymentPodTemplateType0", None, Unset], data)
-
-        pod_template = _parse_pod_template(d.pop("pod_template", UNSET))
+        _pod_template = d.pop("pod_template", UNSET)
+        pod_template: Union[Unset, AgentDeploymentPodTemplate]
+        if isinstance(_pod_template, Unset):
+            pod_template = UNSET
+        else:
+            pod_template = AgentDeploymentPodTemplate.from_dict(_pod_template)
 
         policies = cast(List[str], d.pop("policies", UNSET))
 
@@ -330,22 +285,12 @@ class AgentDeployment:
         else:
             runtime = Runtime.from_dict(_runtime)
 
-        def _parse_serverless_config(data: object) -> Union["DeploymentServerlessConfigType0", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                componentsschemas_deployment_serverless_config_type_0 = DeploymentServerlessConfigType0.from_dict(data)
-
-                return componentsschemas_deployment_serverless_config_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["DeploymentServerlessConfigType0", None, Unset], data)
-
-        serverless_config = _parse_serverless_config(d.pop("serverless_config", UNSET))
+        _serverless_config = d.pop("serverless_config", UNSET)
+        serverless_config: Union[Unset, DeploymentServerlessConfig]
+        if isinstance(_serverless_config, Unset):
+            serverless_config = UNSET
+        else:
+            serverless_config = DeploymentServerlessConfig.from_dict(_serverless_config)
 
         store_id = d.pop("store_id", UNSET)