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

beamlit/common/settings.py

@@ -1,26 +1,56 @@
 import os
 from logging import getLogger
-from typing import Dict, List, Tuple, Type, Union
+from typing import List, Tuple, Type, Union
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langgraph.graph.graph import CompiledGraph
+from pydantic import Field
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
 
 from beamlit.api.functions import get_function_deployment
 from beamlit.api.models import get_model_deployment
 from beamlit.client import AuthenticatedClient
 from beamlit.common.logger import init as init_logger
-from beamlit.models.agent_chain import AgentChain
 from beamlit.models.agent_deployment import AgentDeployment
 from beamlit.models.function_deployment import FunctionDeployment
 from beamlit.models.model_deployment import ModelDeployment
 from beamlit.types import UNSET, Unset
-from pydantic import Field
-from pydantic_settings import (BaseSettings, PydanticBaseSettingsSource,
-                               SettingsConfigDict, YamlConfigSettingsSource)
 
 global SETTINGS
 SETTINGS = None
 
+
 def get_settings():
     return SETTINGS
 
+
+class SettingsAgent(BaseSettings):
+    agent: Union[None, CompiledGraph, BaseChatModel] = None
+    chain: Union[Unset, List[AgentDeployment]] = UNSET
+    model: Union[Unset, ModelDeployment] = UNSET
+    functions: Union[Unset, List[FunctionDeployment]] = UNSET
+    functions_directory: str = Field(default="src/functions")
+    chat_model: Union[None, BaseChatModel] = None
+    module: str = Field(default="main.main")
+
+
+class SettingsAuthentication(BaseSettings):
+    api_key: Union[None, str] = None
+    jwt: Union[None, str] = None
+    client_credentials: Union[None, str] = None
+
+
+class SettingsServer(BaseSettings):
+    module: str = Field(default="main.main")
+    port: int = Field(default=80)
+    host: str = Field(default="0.0.0.0")
+
+
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
         yaml_file="beamlit.yaml",
@@ -28,20 +58,15 @@ class Settings(BaseSettings):
     )
 
     workspace: str
-    type: str
-    name: str
-    environment: str = Field(default="production")
+    environment: str
+    type: str = Field(default="agent")
+    name: str = Field(default="beamlit-agent")
     base_url: str = Field(default="https://api.beamlit.dev/v0")
     run_url: str = Field(default="https://run.beamlit.dev")
-    port: int = Field(default=80)
-    host: str = Field(default="0.0.0.0")
     log_level: str = Field(default="INFO")
-    api_key: Union[None, str] = None
-    jwt: Union[None, str] = None
-    client_credentials: Union[None, str] = None
-    agent_chain:  Union[Unset, List[AgentDeployment]] = UNSET
-    agent_functions: Union[Unset, List[FunctionDeployment]] = UNSET
-    agent_model: Union[Unset, ModelDeployment] = UNSET
+    agent: SettingsAgent = SettingsAgent()
+    server: SettingsServer = SettingsServer()
+    authentication: SettingsAuthentication = SettingsAuthentication()
 
     @classmethod
     def settings_customise_sources(
@@ -52,21 +77,31 @@ class Settings(BaseSettings):
         dotenv_settings: PydanticBaseSettingsSource,
         file_secret_settings: PydanticBaseSettingsSource,
     ) -> Tuple[PydanticBaseSettingsSource, ...]:
-        return (env_settings, dotenv_settings, file_secret_settings, YamlConfigSettingsSource(settings_cls), init_settings, )
-
-def init_agent(client: AuthenticatedClient, destination: str = f"{os.getcwd()}/src/beamlit_generated.py"):
+        return (
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+            YamlConfigSettingsSource(settings_cls),
+            init_settings,
+        )
+
+
+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
 
     logger = getLogger(__name__)
-
+    settings = get_settings()
     # Init configuration from environment variables
-    if SETTINGS.agent_functions or SETTINGS.agent_chain:
+    if settings.agent.functions or settings.agent.chain:
         return
 
     # Init configuration from beamlit control plane
-    name = SETTINGS.name
-    env = SETTINGS.environment
+    name = settings.name
+    env = settings.environment
 
     agent_deployment = get_agent_deployment.sync(name, env, client=client)
     function_deployments = []
@@ -75,7 +110,7 @@ def init_agent(client: AuthenticatedClient, destination: str = f"{os.getcwd()}/s
         for function in agent_deployment.functions:
             function_deployment = get_function_deployment.sync(function, env, client=client)
             function_deployments.append(function_deployment)
-        SETTINGS.agent_functions = function_deployments
+        settings.agent.functions = function_deployments
 
     if agent_deployment.agent_chain:
         for chain in agent_deployment.agent_chain:
@@ -84,24 +119,37 @@ def init_agent(client: AuthenticatedClient, destination: str = f"{os.getcwd()}/s
                 if chain.description:
                     agent_deployment.description = chain.description
                 agent_chain_deployments.append(agent_deployment)
-        SETTINGS.agent_chain = agent_chain_deployments
+        settings.agent.chain = agent_chain_deployments
     if agent_deployment.model:
-        model_deployment = get_model_deployment.sync(agent_deployment.model, env , client=client)
-        SETTINGS.agent_model = model_deployment
+        model_deployment = get_model_deployment.sync(agent_deployment.model, env, client=client)
+        settings.agent.model = model_deployment
 
     content_generate = generate(destination, dry_run=True)
     compared_content = None
     if os.path.exists(destination):
-        compared_content = open(destination, "r").read()
+        compared_content = open(destination).read()
 
-    if not os.path.exists(destination) or (compared_content and content_generate != compared_content):
+    if not os.path.exists(destination) or (
+        compared_content and content_generate != compared_content
+    ):
         logger.info("Generating agent code")
         generate(destination)
 
+
 def init() -> Settings:
     """Parse the beamlit.yaml file to get configurations."""
+    from beamlit.authentication.credentials import current_context
+
     global SETTINGS
 
-    SETTINGS = Settings()
+    context = current_context()
+    kwargs = {}
+    if context.workspace:
+        kwargs["workspace"] = context.workspace
+    if context.environment:
+        kwargs["environment"] = context.environment
+
+    SETTINGS = Settings(**kwargs)
     init_logger(SETTINGS.log_level)
+
     return SETTINGS

beamlit/common/utils.py

@@ -9,5 +9,7 @@ def copy_folder(source_folder: str, destination_folder: str):
             if not os.path.exists(f"{destination_folder}/{file}"):
                 os.makedirs(f"{destination_folder}/{file}")
             copy_folder(f"{source_folder}/{file}", f"{destination_folder}/{file}")
-        elif not os.path.exists(f"{destination_folder}/{file}") or not filecmp.cmp(f"{source_folder}/{file}", f"{destination_folder}/{file}"):
-            shutil.copy(f"{source_folder}/{file}", f"{destination_folder}/{file}")
+        elif not os.path.exists(f"{destination_folder}/{file}") or not filecmp.cmp(
+            f"{source_folder}/{file}", f"{destination_folder}/{file}"
+        ):
+            shutil.copy(f"{source_folder}/{file}", f"{destination_folder}/{file}")

beamlit/functions/__init__.py

@@ -0,0 +1,5 @@
+"""Functions package providing function decorators and utilities."""
+
+from .decorator import function, kit
+
+__all__ = ["function", "kit"]

beamlit/functions/decorator.py

@@ -0,0 +1,90 @@
+"""Decorators for creating function tools with Beamlit and LangChain integration."""
+
+from collections.abc import Callable
+from logging import getLogger
+
+from langchain_core.tools import create_schema_from_function, tool
+
+from beamlit.authentication import new_client
+from beamlit.common.settings import get_settings
+from beamlit.models import FunctionDeployment, FunctionKit
+from beamlit.run import RunClient
+
+logger = getLogger(__name__)
+
+
+def get_remote_function(func: Callable, bl_function: FunctionDeployment):
+    settings = get_settings()
+
+    def _partial(*args, **kwargs):
+        # Get function signature parameters
+        try:
+            client = new_client()
+            run_client = RunClient(client)
+            name = (bl_function and bl_function.function) or func.__name__
+            logger.debug(
+                f"Calling remote function: NAME={name}"
+                f" PARAMS={kwargs} ENVIRONMENT={settings.environment}"
+            )
+            response = run_client.run(
+                resource_type="function",
+                resource_name=name,
+                environment=settings.environment,
+                method="POST",
+                headers={},
+                json=kwargs,
+            )
+            if response.status_code >= 400:
+                content = f"{response.status_code}:{response.text}"
+                return f"Error calling remote function: {content}"
+            logger.debug(
+                f"Response from remote function: NAME={name}"
+                f" RESPONSE={response.json()} ENVIRONMENT={settings.environment}"
+            )
+            return response.json()
+        except Exception as e:
+            logger.error(f"Error calling function {bl_function.id}: {e}")
+            raise e
+
+    remote_func = _partial
+    remote_func.__name__ = func.__name__
+    remote_func.__doc__ = func.__doc__
+    return remote_func
+
+
+def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
+    """Create function tools with Beamlit and LangChain integration."""
+
+    def wrapper(func: Callable) -> Callable:
+        if bl_kit and not func.__doc__ and bl_kit.description:
+            func.__doc__ = bl_kit.description
+        return tool(func, **kwargs)
+
+    return wrapper
+
+
+def function(
+    *args, bl_function: FunctionDeployment = None, kit=False, **kwargs: dict
+) -> Callable:
+    """Create function tools with Beamlit and LangChain integration."""
+    settings = get_settings()
+
+    def wrapper(func: Callable) -> Callable:
+        if bl_function and not func.__doc__ and bl_function.description:
+            func.__doc__ = bl_function.description
+        if (
+            settings.environment == "development"
+            or settings.environment == "production"
+        ):
+            remote_func = get_remote_function(func, bl_function)
+            if not kwargs.get("args_schema"):
+                kwargs["args_schema"] = create_schema_from_function(
+                    func.__name__,
+                    func,
+                    parse_docstring=func.__doc__,
+                )
+            return tool(remote_func, **kwargs)
+        return tool(func, **kwargs)
+
+    return wrapper
+    return wrapper

beamlit/models/acl.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -91,7 +91,7 @@ class ACL:
         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:
         if not src_dict:
             return None
         d = src_dict.copy()

beamlit/models/agent.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -50,7 +50,7 @@ class Agent:
 
         display_name = self.display_name
 
-        labels: Union[Dict[str, Any], None, Unset]
+        labels: Union[None, Unset, dict[str, Any]]
         if isinstance(self.labels, Unset):
             labels = UNSET
         elif isinstance(self.labels, LabelsType0):
@@ -85,7 +85,7 @@ class Agent:
         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:
         from ..models.labels_type_0 import LabelsType0
 
         if not src_dict:

beamlit/models/agent_chain.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -43,7 +43,7 @@ class AgentChain:
         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:
         if not src_dict:
             return None
         d = src_dict.copy()

beamlit/models/agent_configuration.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -37,7 +37,7 @@ class AgentConfiguration:
         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:
         if not src_dict:
             return None
         d = src_dict.copy()

beamlit/models/agent_deployment.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -28,22 +28,22 @@ class AgentDeployment:
         updated_at (Union[Unset, str]): The date and time when the resource was updated
         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
+        agent_chain (Union[Unset, list['AgentChain']]): Agent chaining configuration
         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[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
+        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
             setting it here
-        integration_connections (Union[Unset, List[str]]):
+        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[Unset, AgentDeploymentPodTemplate]): The pod template, should be a valid Kubernetes pod
             template
-        policies (Union[Unset, List[str]]):
+        policies (Union[Unset, list[str]]):
         runtime (Union[Unset, Runtime]): Set of configurations for a deployment
         serverless_config (Union[Unset, DeploymentServerlessConfig]): Configuration for a serverless deployment
         store_id (Union[Unset, str]): Create from a store registered function
@@ -55,18 +55,18 @@ class AgentDeployment:
     updated_at: Union[Unset, str] = UNSET
     updated_by: Union[Unset, str] = UNSET
     agent: Union[Unset, str] = UNSET
-    agent_chain: Union[Unset, List["AgentChain"]] = UNSET
+    agent_chain: Union[Unset, list["AgentChain"]] = UNSET
     configuration: Union[Unset, "AgentDeploymentConfiguration"] = UNSET
     description: Union[Unset, str] = 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
+    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[Unset, "AgentDeploymentPodTemplate"] = UNSET
-    policies: Union[Unset, List[str]] = UNSET
+    policies: Union[Unset, list[str]] = UNSET
     runtime: Union[Unset, "Runtime"] = UNSET
     serverless_config: Union[Unset, "DeploymentServerlessConfig"] = UNSET
     store_id: Union[Unset, str] = UNSET
@@ -86,14 +86,14 @@ class AgentDeployment:
 
         agent = self.agent
 
-        agent_chain: Union[Unset, List[Dict[str, Any]]] = UNSET
+        agent_chain: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.agent_chain, Unset):
             agent_chain = []
             for agent_chain_item_data in self.agent_chain:
                 agent_chain_item = agent_chain_item_data.to_dict()
                 agent_chain.append(agent_chain_item)
 
-        configuration: Union[Unset, Dict[str, Any]] = UNSET
+        configuration: Union[Unset, dict[str, Any]] = UNSET
         if not isinstance(self.configuration, Unset):
             configuration = self.configuration.to_dict()
 
@@ -103,22 +103,22 @@ class AgentDeployment:
 
         environment = self.environment
 
-        flavors: Union[Unset, List[Dict[str, Any]]] = UNSET
+        flavors: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.flavors, Unset):
             flavors = []
             for componentsschemas_flavors_item_data in self.flavors:
                 componentsschemas_flavors_item = componentsschemas_flavors_item_data.to_dict()
                 flavors.append(componentsschemas_flavors_item)
 
-        functions: Union[Unset, List[str]] = UNSET
+        functions: Union[Unset, list[str]] = UNSET
         if not isinstance(self.functions, Unset):
             functions = self.functions
 
-        integration_connections: Union[Unset, List[str]] = UNSET
+        integration_connections: Union[Unset, list[str]] = UNSET
         if not isinstance(self.integration_connections, Unset):
             integration_connections = self.integration_connections
 
-        labels: Union[Dict[str, Any], None, Unset]
+        labels: Union[None, Unset, dict[str, Any]]
         if isinstance(self.labels, Unset):
             labels = UNSET
         elif isinstance(self.labels, LabelsType0):
@@ -128,19 +128,19 @@ class AgentDeployment:
 
         model = self.model
 
-        pod_template: Union[Unset, Dict[str, Any]] = UNSET
+        pod_template: Union[Unset, dict[str, Any]] = UNSET
         if not isinstance(self.pod_template, Unset):
             pod_template = self.pod_template.to_dict()
 
-        policies: Union[Unset, List[str]] = UNSET
+        policies: Union[Unset, list[str]] = UNSET
         if not isinstance(self.policies, Unset):
             policies = self.policies
 
-        runtime: Union[Unset, Dict[str, Any]] = UNSET
+        runtime: Union[Unset, dict[str, Any]] = UNSET
         if not isinstance(self.runtime, Unset):
             runtime = self.runtime.to_dict()
 
-        serverless_config: Union[Unset, Dict[str, Any]] = UNSET
+        serverless_config: Union[Unset, dict[str, Any]] = UNSET
         if not isinstance(self.serverless_config, Unset):
             serverless_config = self.serverless_config.to_dict()
 
@@ -197,7 +197,7 @@ class AgentDeployment:
         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:
         from ..models.agent_chain import AgentChain
         from ..models.agent_deployment_configuration import AgentDeploymentConfiguration
         from ..models.agent_deployment_pod_template import AgentDeploymentPodTemplate
@@ -246,9 +246,9 @@ class AgentDeployment:
 
             flavors.append(componentsschemas_flavors_item)
 
-        functions = cast(List[str], d.pop("functions", UNSET))
+        functions = cast(list[str], d.pop("functions", UNSET))
 
-        integration_connections = cast(List[str], d.pop("integration_connections", UNSET))
+        integration_connections = cast(list[str], d.pop("integration_connections", UNSET))
 
         def _parse_labels(data: object) -> Union["LabelsType0", None, Unset]:
             if data is None:
@@ -276,7 +276,7 @@ class AgentDeployment:
         else:
             pod_template = AgentDeploymentPodTemplate.from_dict(_pod_template)
 
-        policies = cast(List[str], d.pop("policies", UNSET))
+        policies = cast(list[str], d.pop("policies", UNSET))
 
         _runtime = d.pop("runtime", UNSET)
         runtime: Union[Unset, Runtime]

beamlit/models/agent_deployment_configuration.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar
+from typing import Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -19,7 +19,7 @@ class AgentDeploymentConfiguration:
         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:
         if not src_dict:
             return None
         d = src_dict.copy()

beamlit/models/agent_deployment_history.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -24,7 +24,7 @@ class AgentDeploymentHistory:
         agent (Union[Unset, str]): Agent name
         end (Union[Unset, str]): End time
         environment (Union[Unset, str]): Environment name
-        events (Union[Unset, List['AgentDeploymentHistoryEvent']]): Events
+        events (Union[Unset, list['AgentDeploymentHistoryEvent']]): Events
         request_id (Union[Unset, str]): Request ID
         start (Union[Unset, str]): Start time
         status (Union[Unset, str]): Status, eg: running, success, failed
@@ -39,7 +39,7 @@ class AgentDeploymentHistory:
     agent: Union[Unset, str] = UNSET
     end: Union[Unset, str] = UNSET
     environment: Union[Unset, str] = UNSET
-    events: Union[Unset, List["AgentDeploymentHistoryEvent"]] = UNSET
+    events: Union[Unset, list["AgentDeploymentHistoryEvent"]] = UNSET
     request_id: Union[Unset, str] = UNSET
     start: Union[Unset, str] = UNSET
     status: Union[Unset, str] = UNSET
@@ -62,7 +62,7 @@ class AgentDeploymentHistory:
 
         environment = self.environment
 
-        events: Union[Unset, List[Dict[str, Any]]] = UNSET
+        events: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.events, Unset):
             events = []
             for events_item_data in self.events:
@@ -112,7 +112,7 @@ class AgentDeploymentHistory:
         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:
         from ..models.agent_deployment_history_event import AgentDeploymentHistoryEvent
 
         if not src_dict:

beamlit/models/agent_deployment_history_event.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -21,7 +21,7 @@ class AgentDeploymentHistoryEvent:
         status (Union[Unset, str]): Status, eg: running, success, failed
         sub_function (Union[Unset, str]): Function used in kit if a kit was used
         took (Union[Unset, int]): Number of milliseconds it took to complete the event
-        type (Union[Unset, str]): Type, one of function or agent
+        type_ (Union[Unset, str]): Type, one of function or agent
     """
 
     end: Union[Unset, str] = UNSET
@@ -32,7 +32,7 @@ class AgentDeploymentHistoryEvent:
     status: Union[Unset, str] = UNSET
     sub_function: Union[Unset, str] = UNSET
     took: Union[Unset, int] = UNSET
-    type: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -52,7 +52,7 @@ class AgentDeploymentHistoryEvent:
 
         took = self.took
 
-        type = self.type
+        type_ = self.type_
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
@@ -73,13 +73,13 @@ class AgentDeploymentHistoryEvent:
             field_dict["sub_function"] = sub_function
         if took is not UNSET:
             field_dict["took"] = took
-        if type is not UNSET:
-            field_dict["type"] = type
+        if type_ is not UNSET:
+            field_dict["type"] = type_
 
         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:
         if not src_dict:
             return None
         d = src_dict.copy()
@@ -99,7 +99,7 @@ class AgentDeploymentHistoryEvent:
 
         took = d.pop("took", UNSET)
 
-        type = d.pop("type", UNSET)
+        type_ = d.pop("type", UNSET)
 
         agent_deployment_history_event = cls(
             end=end,
@@ -110,7 +110,7 @@ class AgentDeploymentHistoryEvent:
             status=status,
             sub_function=sub_function,
             took=took,
-            type=type,
+            type_=type_,
         )
 
         agent_deployment_history_event.additional_properties = d

beamlit/models/agent_deployment_pod_template.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar
+from typing import Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -19,7 +19,7 @@ class AgentDeploymentPodTemplate:
         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:
         if not src_dict:
             return None
         d = src_dict.copy()

beamlit/models/agent_release.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -37,7 +37,7 @@ class AgentRelease:
         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:
         if not src_dict:
             return None
         d = src_dict.copy()