beamlit 0.1.0__py3-none-any.whl

beamlit/client.py

@@ -0,0 +1,270 @@
+import ssl
+from typing import Any, Optional, Union
+
+import httpx
+from attrs import define, evolve, field
+
+
+@define
+class Client:
+    """A class for keeping track of data related to the API
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``provider``: An implementation of httpx.Auth to use for authentication
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+    Attributes:
+        raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+            status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+            argument to the constructor.
+
+    """
+
+    raise_on_unexpected_status: bool = field(default=True, kw_only=True)
+    _base_url: str = field(alias="base_url", default="https://api.beamlit.dev/v0")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _provider: httpx.Auth = field(default=None, alias="provider")
+    _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout")
+    _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl")
+    _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects")
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: Optional[httpx.Client] = field(default=None, init=False)
+    _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False)
+
+    def with_headers(self, headers: dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> "Client":
+        """Get a new client matching this one with a new timeout (in seconds)"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> "Client":
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                auth=self._provider,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> "Client":
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "Client":
+        """Manually the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> "Client":
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)
+
+
+@define
+class AuthenticatedClient:
+    """A Client which has been authenticated for use on secured endpoints
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``provider``: An implementation of httpx.Auth to use for authentication
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+    Attributes:
+        raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+            status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+            argument to the constructor.
+        provider: AuthProvider to use for authentication
+    """
+
+    raise_on_unexpected_status: bool = field(default=True, kw_only=True)
+    _base_url: str = field(alias="base_url", default="https://api.beamlit.dev/v0")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _provider: httpx.Auth = field(default=None, alias="provider")
+    _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout")
+    _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl")
+    _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects")
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: Optional[httpx.Client] = field(default=None, init=False)
+    _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False)
+
+    def with_headers(self, headers: dict[str, str]) -> "AuthenticatedClient":
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> "AuthenticatedClient":
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> "AuthenticatedClient":
+        """Get a new client matching this one with a new timeout (in seconds)"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> "AuthenticatedClient":
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                auth=self._provider,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> "AuthenticatedClient":
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "AuthenticatedClient":
+        """Manually the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._headers[self.auth_header_name] = f"{self.prefix} {self.token}" if self.prefix else self.token
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> "AuthenticatedClient":
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)

beamlit/errors.py

@@ -0,0 +1,16 @@
+"""Contains shared errors types that can be raised from API functions"""
+
+
+class UnexpectedStatus(Exception):
+    """Raised by api functions when the response status an undocumented status and Client.raise_on_unexpected_status is True"""
+
+    def __init__(self, status_code: int, content: bytes):
+        self.status_code = status_code
+        self.content = content
+
+        super().__init__(
+            f"Unexpected status code: {status_code}\n\nResponse content:\n{content.decode(errors='ignore')}"
+        )
+
+
+__all__ = ["UnexpectedStatus"]

beamlit/models/__init__.py

@@ -0,0 +1,189 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from .acl import ACL
+from .agent import Agent
+from .agent_chain import AgentChain
+from .agent_configuration import AgentConfiguration
+from .agent_deployment import AgentDeployment
+from .agent_deployment_configuration import AgentDeploymentConfiguration
+from .agent_deployment_history import AgentDeploymentHistory
+from .agent_deployment_history_event import AgentDeploymentHistoryEvent
+from .agent_deployment_pod_template import AgentDeploymentPodTemplate
+from .agent_release import AgentRelease
+from .api_key import ApiKey
+from .authentication_provider_model import AuthenticationProviderModel
+from .authentication_provider_organization import AuthenticationProviderOrganization
+from .configuration import Configuration
+from .continent import Continent
+from .country import Country
+from .create_api_key_for_service_account_body import CreateApiKeyForServiceAccountBody
+from .create_workspace_service_account_body import CreateWorkspaceServiceAccountBody
+from .create_workspace_service_account_response_200 import CreateWorkspaceServiceAccountResponse200
+from .delete_workspace_service_account_response_200 import DeleteWorkspaceServiceAccountResponse200
+from .deployment_configuration import DeploymentConfiguration
+from .deployment_configurations import DeploymentConfigurations
+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 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
+from .get_workspace_service_accounts_response_200_item import GetWorkspaceServiceAccountsResponse200Item
+from .invite_workspace_user_body import InviteWorkspaceUserBody
+from .labels_type_0 import LabelsType0
+from .location import Location
+from .location_response import LocationResponse
+from .metric import Metric
+from .metrics import Metrics
+from .model import Model
+from .model_deployment import ModelDeployment
+from .model_deployment_log import ModelDeploymentLog
+from .model_deployment_metrics import ModelDeploymentMetrics
+from .model_deployment_metrics_inference_per_second_per_region import ModelDeploymentMetricsInferencePerSecondPerRegion
+from .model_deployment_metrics_query_per_second_per_region_per_code import (
+    ModelDeploymentMetricsQueryPerSecondPerRegionPerCode,
+)
+from .model_deployment_pod_template import ModelDeploymentPodTemplate
+from .model_metrics import ModelMetrics
+from .model_provider import ModelProvider
+from .model_provider_ref import ModelProviderRef
+from .model_release import ModelRelease
+from .model_with_deployments import ModelWithDeployments
+from .pending_invitation import PendingInvitation
+from .pending_invitation_accept import PendingInvitationAccept
+from .pending_invitation_render import PendingInvitationRender
+from .pending_invitation_render_invited_by import PendingInvitationRenderInvitedBy
+from .pending_invitation_render_workspace import PendingInvitationRenderWorkspace
+from .pending_invitation_workspace_details import PendingInvitationWorkspaceDetails
+from .policy import Policy
+from .policy_location import PolicyLocation
+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_second_per_region import (
+    ResourceDeploymentMetricsInferencePerSecondPerRegion,
+)
+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 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 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 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
+from .update_workspace_user_role_body import UpdateWorkspaceUserRoleBody
+from .workspace import Workspace
+from .workspace_labels import WorkspaceLabels
+from .workspace_user import WorkspaceUser
+
+__all__ = (
+    "ACL",
+    "Agent",
+    "AgentChain",
+    "AgentConfiguration",
+    "AgentDeployment",
+    "AgentDeploymentConfiguration",
+    "AgentDeploymentHistory",
+    "AgentDeploymentHistoryEvent",
+    "AgentDeploymentPodTemplate",
+    "AgentRelease",
+    "ApiKey",
+    "AuthenticationProviderModel",
+    "AuthenticationProviderOrganization",
+    "Configuration",
+    "Continent",
+    "Country",
+    "CreateApiKeyForServiceAccountBody",
+    "CreateWorkspaceServiceAccountBody",
+    "CreateWorkspaceServiceAccountResponse200",
+    "DeleteWorkspaceServiceAccountResponse200",
+    "DeploymentConfiguration",
+    "DeploymentConfigurations",
+    "DeploymentServerlessConfig",
+    "Environment",
+    "EnvironmentMetrics",
+    "Flavor",
+    "Function",
+    "FunctionConfiguration",
+    "FunctionDeployment",
+    "FunctionDeploymentConfiguration",
+    "FunctionDeploymentPodTemplate",
+    "FunctionKit",
+    "FunctionProviderRef",
+    "FunctionRelease",
+    "GetWorkspaceServiceAccountsResponse200Item",
+    "InviteWorkspaceUserBody",
+    "LabelsType0",
+    "Location",
+    "LocationResponse",
+    "Metric",
+    "Metrics",
+    "Model",
+    "ModelDeployment",
+    "ModelDeploymentLog",
+    "ModelDeploymentMetrics",
+    "ModelDeploymentMetricsInferencePerSecondPerRegion",
+    "ModelDeploymentMetricsQueryPerSecondPerRegionPerCode",
+    "ModelDeploymentPodTemplate",
+    "ModelMetrics",
+    "ModelProvider",
+    "ModelProviderRef",
+    "ModelRelease",
+    "ModelWithDeployments",
+    "PendingInvitation",
+    "PendingInvitationAccept",
+    "PendingInvitationRender",
+    "PendingInvitationRenderInvitedBy",
+    "PendingInvitationRenderWorkspace",
+    "PendingInvitationWorkspaceDetails",
+    "Policy",
+    "PolicyLocation",
+    "ProviderConfig",
+    "QPS",
+    "ResourceDeploymentLog",
+    "ResourceDeploymentMetrics",
+    "ResourceDeploymentMetricsInferencePerSecondPerRegion",
+    "ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode",
+    "ResourceMetrics",
+    "Runtime",
+    "RuntimeReadinessProbe",
+    "RuntimeResources",
+    "ServerlessConfig",
+    "StandardFieldsDynamoDb",
+    "StoreAgent",
+    "StoreAgentConfiguration",
+    "StoreAgentLabels",
+    "StoreConfiguration",
+    "StoreConfigurationOption",
+    "StoreFunction",
+    "StoreFunctionConfiguration",
+    "StoreFunctionKit",
+    "StoreFunctionLabels",
+    "StoreFunctionParameter",
+    "UpdateWorkspaceServiceAccountBody",
+    "UpdateWorkspaceServiceAccountResponse200",
+    "UpdateWorkspaceUserRoleBody",
+    "Workspace",
+    "WorkspaceLabels",
+    "WorkspaceUser",
+)

beamlit/models/acl.py

@@ -0,0 +1,149 @@
+from typing import Any, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ACL")
+
+
+@_attrs_define
+class ACL:
+    """ACL
+
+    Attributes:
+        created_at (Union[Unset, str]): The date and time when the resource was created
+        created_by (Union[Unset, str]): The user or service account who created the resource
+        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
+        id (Union[Unset, str]): ACL id
+        resource_id (Union[Unset, str]): Resource ID
+        resource_type (Union[Unset, str]): Resource type
+        role (Union[Unset, str]): Role
+        subject_id (Union[Unset, str]): Subject ID
+        subject_type (Union[Unset, str]): Subject type
+        workspace (Union[Unset, str]): Workspace name
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    created_by: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    updated_by: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    resource_id: Union[Unset, str] = UNSET
+    resource_type: Union[Unset, str] = UNSET
+    role: Union[Unset, str] = UNSET
+    subject_id: Union[Unset, str] = UNSET
+    subject_type: 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]:
+        created_at = self.created_at
+
+        created_by = self.created_by
+
+        updated_at = self.updated_at
+
+        updated_by = self.updated_by
+
+        id = self.id
+
+        resource_id = self.resource_id
+
+        resource_type = self.resource_type
+
+        role = self.role
+
+        subject_id = self.subject_id
+
+        subject_type = self.subject_type
+
+        workspace = self.workspace
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if created_by is not UNSET:
+            field_dict["created_by"] = created_by
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+        if updated_by is not UNSET:
+            field_dict["updated_by"] = updated_by
+        if id is not UNSET:
+            field_dict["id"] = id
+        if resource_id is not UNSET:
+            field_dict["resource_id"] = resource_id
+        if resource_type is not UNSET:
+            field_dict["resource_type"] = resource_type
+        if role is not UNSET:
+            field_dict["role"] = role
+        if subject_id is not UNSET:
+            field_dict["subject_id"] = subject_id
+        if subject_type is not UNSET:
+            field_dict["subject_type"] = subject_type
+        if workspace is not UNSET:
+            field_dict["workspace"] = workspace
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        created_at = d.pop("created_at", UNSET)
+
+        created_by = d.pop("created_by", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        updated_by = d.pop("updated_by", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        resource_id = d.pop("resource_id", UNSET)
+
+        resource_type = d.pop("resource_type", UNSET)
+
+        role = d.pop("role", UNSET)
+
+        subject_id = d.pop("subject_id", UNSET)
+
+        subject_type = d.pop("subject_type", UNSET)
+
+        workspace = d.pop("workspace", UNSET)
+
+        acl = cls(
+            created_at=created_at,
+            created_by=created_by,
+            updated_at=updated_at,
+            updated_by=updated_by,
+            id=id,
+            resource_id=resource_id,
+            resource_type=resource_type,
+            role=role,
+            subject_id=subject_id,
+            subject_type=subject_type,
+            workspace=workspace,
+        )
+
+        acl.additional_properties = d
+        return acl
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties