beamlit 0.1.0__py3-none-any.whl

beamlit/models/authentication_provider_organization.py

@@ -0,0 +1,86 @@
+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="AuthenticationProviderOrganization")
+
+
+@_attrs_define
+class AuthenticationProviderOrganization:
+    """Organization that hosts models from an external authentication provider (HuggingFace, OpenAI, etc...)
+
+    Attributes:
+        avatar_url (Union[Unset, str]): Provider organization avatar URL
+        display_name (Union[Unset, str]): Provider organization display name
+        id (Union[Unset, str]): Provider organization ID
+        name (Union[Unset, str]): Provider organization name
+    """
+
+    avatar_url: Union[Unset, str] = UNSET
+    display_name: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        avatar_url = self.avatar_url
+
+        display_name = self.display_name
+
+        id = self.id
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if avatar_url is not UNSET:
+            field_dict["avatar_url"] = avatar_url
+        if display_name is not UNSET:
+            field_dict["display_name"] = display_name
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        avatar_url = d.pop("avatar_url", UNSET)
+
+        display_name = d.pop("display_name", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        authentication_provider_organization = cls(
+            avatar_url=avatar_url,
+            display_name=display_name,
+            id=id,
+            name=name,
+        )
+
+        authentication_provider_organization.additional_properties = d
+        return authentication_provider_organization
+
+    @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

beamlit/models/configuration.py

@@ -0,0 +1,72 @@
+from typing import Any, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Configuration")
+
+
+@_attrs_define
+class Configuration:
+    """Configuration
+
+    Attributes:
+        continents (Union[Unset, List[Any]]): Continents
+        countries (Union[Unset, List[Any]]): Countries
+    """
+
+    continents: Union[Unset, List[Any]] = UNSET
+    countries: Union[Unset, List[Any]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        continents: Union[Unset, List[Any]] = UNSET
+        if not isinstance(self.continents, Unset):
+            continents = self.continents
+
+        countries: Union[Unset, List[Any]] = UNSET
+        if not isinstance(self.countries, Unset):
+            countries = self.countries
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if continents is not UNSET:
+            field_dict["continents"] = continents
+        if countries is not UNSET:
+            field_dict["countries"] = countries
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        continents = cast(List[Any], d.pop("continents", UNSET))
+
+        countries = cast(List[Any], d.pop("countries", UNSET))
+
+        configuration = cls(
+            continents=continents,
+            countries=countries,
+        )
+
+        configuration.additional_properties = d
+        return configuration
+
+    @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

beamlit/models/continent.py

@@ -0,0 +1,68 @@
+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="Continent")
+
+
+@_attrs_define
+class Continent:
+    """Continent
+
+    Attributes:
+        display_name (Union[Unset, str]): Continent display name
+        name (Union[Unset, str]): Continent code
+    """
+
+    display_name: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        display_name = self.display_name
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if display_name is not UNSET:
+            field_dict["display_name"] = display_name
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        display_name = d.pop("display_name", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        continent = cls(
+            display_name=display_name,
+            name=name,
+        )
+
+        continent.additional_properties = d
+        return continent
+
+    @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

beamlit/models/country.py

@@ -0,0 +1,68 @@
+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="Country")
+
+
+@_attrs_define
+class Country:
+    """Configuration
+
+    Attributes:
+        display_name (Union[Unset, str]): Country display name
+        name (Union[Unset, str]): Country code
+    """
+
+    display_name: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        display_name = self.display_name
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if display_name is not UNSET:
+            field_dict["display_name"] = display_name
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        display_name = d.pop("display_name", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        country = cls(
+            display_name=display_name,
+            name=name,
+        )
+
+        country.additional_properties = d
+        return country
+
+    @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

beamlit/models/create_api_key_for_service_account_body.py

@@ -0,0 +1,67 @@
+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="CreateApiKeyForServiceAccountBody")
+
+
+@_attrs_define
+class CreateApiKeyForServiceAccountBody:
+    """
+    Attributes:
+        expires_in (Union[Unset, str]): Expiration period for the API key
+        name (Union[Unset, str]): Name for the API key
+    """
+
+    expires_in: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        expires_in = self.expires_in
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if expires_in is not UNSET:
+            field_dict["expires_in"] = expires_in
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        expires_in = d.pop("expires_in", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        create_api_key_for_service_account_body = cls(
+            expires_in=expires_in,
+            name=name,
+        )
+
+        create_api_key_for_service_account_body.additional_properties = d
+        return create_api_key_for_service_account_body
+
+    @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

beamlit/models/create_workspace_service_account_body.py

@@ -0,0 +1,69 @@
+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="CreateWorkspaceServiceAccountBody")
+
+
+@_attrs_define
+class CreateWorkspaceServiceAccountBody:
+    """
+    Attributes:
+        name (str): Service account name
+        description (Union[Unset, str]): Service account description
+    """
+
+    name: str
+    description: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        description = d.pop("description", UNSET)
+
+        create_workspace_service_account_body = cls(
+            name=name,
+            description=description,
+        )
+
+        create_workspace_service_account_body.additional_properties = d
+        return create_workspace_service_account_body
+
+    @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

beamlit/models/create_workspace_service_account_response_200.py

@@ -0,0 +1,103 @@
+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="CreateWorkspaceServiceAccountResponse200")
+
+
+@_attrs_define
+class CreateWorkspaceServiceAccountResponse200:
+    """
+    Attributes:
+        client_id (Union[Unset, str]): Service account client ID
+        client_secret (Union[Unset, str]): Service account client secret (only returned on creation)
+        created_at (Union[Unset, str]): Creation timestamp
+        description (Union[Unset, str]): Service account description
+        name (Union[Unset, str]): Service account name
+        updated_at (Union[Unset, str]): Last update timestamp
+    """
+
+    client_id: Union[Unset, str] = UNSET
+    client_secret: Union[Unset, str] = UNSET
+    created_at: Union[Unset, str] = UNSET
+    description: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        client_secret = self.client_secret
+
+        created_at = self.created_at
+
+        description = self.description
+
+        name = self.name
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if client_secret is not UNSET:
+            field_dict["client_secret"] = client_secret
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if description is not UNSET:
+            field_dict["description"] = description
+        if name is not UNSET:
+            field_dict["name"] = name
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        client_id = d.pop("client_id", UNSET)
+
+        client_secret = d.pop("client_secret", UNSET)
+
+        created_at = d.pop("created_at", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        create_workspace_service_account_response_200 = cls(
+            client_id=client_id,
+            client_secret=client_secret,
+            created_at=created_at,
+            description=description,
+            name=name,
+            updated_at=updated_at,
+        )
+
+        create_workspace_service_account_response_200.additional_properties = d
+        return create_workspace_service_account_response_200
+
+    @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

beamlit/models/delete_workspace_service_account_response_200.py

@@ -0,0 +1,94 @@
+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="DeleteWorkspaceServiceAccountResponse200")
+
+
+@_attrs_define
+class DeleteWorkspaceServiceAccountResponse200:
+    """
+    Attributes:
+        client_id (Union[Unset, str]): Service account client ID
+        created_at (Union[Unset, str]): Creation timestamp
+        description (Union[Unset, str]): Service account description
+        name (Union[Unset, str]): Service account name
+        updated_at (Union[Unset, str]): Last update timestamp
+    """
+
+    client_id: Union[Unset, str] = UNSET
+    created_at: Union[Unset, str] = UNSET
+    description: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        created_at = self.created_at
+
+        description = self.description
+
+        name = self.name
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if description is not UNSET:
+            field_dict["description"] = description
+        if name is not UNSET:
+            field_dict["name"] = name
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        client_id = d.pop("client_id", UNSET)
+
+        created_at = d.pop("created_at", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        delete_workspace_service_account_response_200 = cls(
+            client_id=client_id,
+            created_at=created_at,
+            description=description,
+            name=name,
+            updated_at=updated_at,
+        )
+
+        delete_workspace_service_account_response_200.additional_properties = d
+        return delete_workspace_service_account_response_200
+
+    @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

beamlit/models/deployment_configuration.py

@@ -0,0 +1,68 @@
+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="DeploymentConfiguration")
+
+
+@_attrs_define
+class DeploymentConfiguration:
+    """Function configuration, this is a key value storage. In your function you can retrieve the value with config[key]
+
+    Attributes:
+        secret (Union[Unset, bool]): Function configuration secret
+        value (Union[Unset, str]): Function configuration value
+    """
+
+    secret: Union[Unset, bool] = UNSET
+    value: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        secret = self.secret
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if secret is not UNSET:
+            field_dict["secret"] = secret
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        secret = d.pop("secret", UNSET)
+
+        value = d.pop("value", UNSET)
+
+        deployment_configuration = cls(
+            secret=secret,
+            value=value,
+        )
+
+        deployment_configuration.additional_properties = d
+        return deployment_configuration
+
+    @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