beamlit 0.1.0__py3-none-any.whl

beamlit/models/get_workspace_service_accounts_response_200_item.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="GetWorkspaceServiceAccountsResponse200Item")
+
+
+@_attrs_define
+class GetWorkspaceServiceAccountsResponse200Item:
+    """
+    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)
+
+        get_workspace_service_accounts_response_200_item = cls(
+            client_id=client_id,
+            created_at=created_at,
+            description=description,
+            name=name,
+            updated_at=updated_at,
+        )
+
+        get_workspace_service_accounts_response_200_item.additional_properties = d
+        return get_workspace_service_accounts_response_200_item
+
+    @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/invite_workspace_user_body.py

@@ -0,0 +1,58 @@
+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="InviteWorkspaceUserBody")
+
+
+@_attrs_define
+class InviteWorkspaceUserBody:
+    """
+    Attributes:
+        email (Union[Unset, str]):
+    """
+
+    email: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        email = self.email
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if email is not UNSET:
+            field_dict["email"] = email
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        email = d.pop("email", UNSET)
+
+        invite_workspace_user_body = cls(
+            email=email,
+        )
+
+        invite_workspace_user_body.additional_properties = d
+        return invite_workspace_user_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/labels.py

@@ -0,0 +1,43 @@
+from typing import Any, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Labels")
+
+
+@_attrs_define
+class Labels:
+    """Labels"""
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        labels = cls()
+
+        labels.additional_properties = d
+        return labels
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/labels_type_0.py

@@ -0,0 +1,43 @@
+from typing import Any, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="LabelsType0")
+
+
+@_attrs_define
+class LabelsType0:
+    """Labels"""
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        labels_type_0 = cls()
+
+        labels_type_0.additional_properties = d
+        return labels_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/location.py

@@ -0,0 +1,120 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.flavor import Flavor
+
+
+T = TypeVar("T", bound="Location")
+
+
+@_attrs_define
+class Location:
+    """Location availability for policies
+
+    Attributes:
+        continent (Union[Unset, str]): Location continent
+        country (Union[Unset, str]): Location country
+        flavors (Union[Unset, List['Flavor']]): Location flavors
+        location (Union[Unset, str]): Location name
+        name (Union[Unset, str]): Location name
+        status (Union[Unset, str]): Location status
+    """
+
+    continent: Union[Unset, str] = UNSET
+    country: Union[Unset, str] = UNSET
+    flavors: Union[Unset, List["Flavor"]] = UNSET
+    location: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    status: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        continent = self.continent
+
+        country = self.country
+
+        flavors: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.flavors, Unset):
+            flavors = []
+            for flavors_item_data in self.flavors:
+                flavors_item = flavors_item_data.to_dict()
+                flavors.append(flavors_item)
+
+        location = self.location
+
+        name = self.name
+
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if continent is not UNSET:
+            field_dict["continent"] = continent
+        if country is not UNSET:
+            field_dict["country"] = country
+        if flavors is not UNSET:
+            field_dict["flavors"] = flavors
+        if location is not UNSET:
+            field_dict["location"] = location
+        if name is not UNSET:
+            field_dict["name"] = name
+        if status is not UNSET:
+            field_dict["status"] = status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.flavor import Flavor
+
+        d = src_dict.copy()
+        continent = d.pop("continent", UNSET)
+
+        country = d.pop("country", UNSET)
+
+        flavors = []
+        _flavors = d.pop("flavors", UNSET)
+        for flavors_item_data in _flavors or []:
+            flavors_item = Flavor.from_dict(flavors_item_data)
+
+            flavors.append(flavors_item)
+
+        location = d.pop("location", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        status = d.pop("status", UNSET)
+
+        location = cls(
+            continent=continent,
+            country=country,
+            flavors=flavors,
+            location=location,
+            name=name,
+            status=status,
+        )
+
+        location.additional_properties = d
+        return location
+
+    @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/location_response.py

@@ -0,0 +1,111 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.flavor import Flavor
+
+
+T = TypeVar("T", bound="LocationResponse")
+
+
+@_attrs_define
+class LocationResponse:
+    """Location availability for policies
+
+    Attributes:
+        continent (Union[Unset, str]): Continent of the location
+        country (Union[Unset, str]): Country of the location
+        flavors (Union[Unset, List['Flavor']]): Hardware flavors available in the location
+        location (Union[Unset, str]): Name of the location
+        status (Union[Unset, str]): Status of the location
+    """
+
+    continent: Union[Unset, str] = UNSET
+    country: Union[Unset, str] = UNSET
+    flavors: Union[Unset, List["Flavor"]] = UNSET
+    location: Union[Unset, str] = UNSET
+    status: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        continent = self.continent
+
+        country = self.country
+
+        flavors: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.flavors, Unset):
+            flavors = []
+            for flavors_item_data in self.flavors:
+                flavors_item = flavors_item_data.to_dict()
+                flavors.append(flavors_item)
+
+        location = self.location
+
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if continent is not UNSET:
+            field_dict["continent"] = continent
+        if country is not UNSET:
+            field_dict["country"] = country
+        if flavors is not UNSET:
+            field_dict["flavors"] = flavors
+        if location is not UNSET:
+            field_dict["location"] = location
+        if status is not UNSET:
+            field_dict["status"] = status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.flavor import Flavor
+
+        d = src_dict.copy()
+        continent = d.pop("continent", UNSET)
+
+        country = d.pop("country", UNSET)
+
+        flavors = []
+        _flavors = d.pop("flavors", UNSET)
+        for flavors_item_data in _flavors or []:
+            flavors_item = Flavor.from_dict(flavors_item_data)
+
+            flavors.append(flavors_item)
+
+        location = d.pop("location", UNSET)
+
+        status = d.pop("status", UNSET)
+
+        location_response = cls(
+            continent=continent,
+            country=country,
+            flavors=flavors,
+            location=location,
+            status=status,
+        )
+
+        location_response.additional_properties = d
+        return location_response
+
+    @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/metric.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="Metric")
+
+
+@_attrs_define
+class Metric:
+    """Metric
+
+    Attributes:
+        timestamp (Union[Unset, str]): Metric timestamp
+        value (Union[Unset, str]): Metric value
+    """
+
+    timestamp: Union[Unset, str] = UNSET
+    value: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timestamp = self.timestamp
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        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()
+        timestamp = d.pop("timestamp", UNSET)
+
+        value = d.pop("value", UNSET)
+
+        metric = cls(
+            timestamp=timestamp,
+            value=value,
+        )
+
+        metric.additional_properties = d
+        return metric
+
+    @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/metrics.py

@@ -0,0 +1,111 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.metric import Metric
+
+
+T = TypeVar("T", bound="Metrics")
+
+
+@_attrs_define
+class Metrics:
+    """Metrics for resources
+
+    Attributes:
+        agents (Union[Unset, Any]): Metrics for agents
+        functions (Union[Unset, Any]): Metrics for functions
+        inference_per_second_global (Union[Unset, List['Metric']]): Array of metrics
+        models (Union[Unset, Any]): Metrics for models
+        query_per_second (Union[Unset, float]): RPS value (in last 24 hours) per location, for all resources globally
+    """
+
+    agents: Union[Unset, Any] = UNSET
+    functions: Union[Unset, Any] = UNSET
+    inference_per_second_global: Union[Unset, List["Metric"]] = UNSET
+    models: Union[Unset, Any] = UNSET
+    query_per_second: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        agents = self.agents
+
+        functions = self.functions
+
+        inference_per_second_global: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.inference_per_second_global, Unset):
+            inference_per_second_global = []
+            for componentsschemas_array_metric_item_data in self.inference_per_second_global:
+                componentsschemas_array_metric_item = componentsschemas_array_metric_item_data.to_dict()
+                inference_per_second_global.append(componentsschemas_array_metric_item)
+
+        models = self.models
+
+        query_per_second = self.query_per_second
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if agents is not UNSET:
+            field_dict["agents"] = agents
+        if functions is not UNSET:
+            field_dict["functions"] = functions
+        if inference_per_second_global is not UNSET:
+            field_dict["inference_per_second_global"] = inference_per_second_global
+        if models is not UNSET:
+            field_dict["models"] = models
+        if query_per_second is not UNSET:
+            field_dict["query_per_second"] = query_per_second
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.metric import Metric
+
+        d = src_dict.copy()
+        agents = d.pop("agents", UNSET)
+
+        functions = d.pop("functions", UNSET)
+
+        inference_per_second_global = []
+        _inference_per_second_global = d.pop("inference_per_second_global", UNSET)
+        for componentsschemas_array_metric_item_data in _inference_per_second_global or []:
+            componentsschemas_array_metric_item = Metric.from_dict(componentsschemas_array_metric_item_data)
+
+            inference_per_second_global.append(componentsschemas_array_metric_item)
+
+        models = d.pop("models", UNSET)
+
+        query_per_second = d.pop("query_per_second", UNSET)
+
+        metrics = cls(
+            agents=agents,
+            functions=functions,
+            inference_per_second_global=inference_per_second_global,
+            models=models,
+            query_per_second=query_per_second,
+        )
+
+        metrics.additional_properties = d
+        return metrics
+
+    @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