beamlit 0.0.33rc50__py3-none-any.whl → 0.0.34__py3-none-any.whl

beamlit/models/metrics_request_total_per_code.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="MetricsRequestTotalPerCode")
+
+
+@_attrs_define
+class MetricsRequestTotalPerCode:
+    """Number of requests for all resources globally per code"""
+
+    additional_properties: dict[str, Any] = _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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        metrics_request_total_per_code = cls()
+
+        metrics_request_total_per_code.additional_properties = d
+        return metrics_request_total_per_code
+
+    @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_rps_per_code.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="MetricsRpsPerCode")
+
+
+@_attrs_define
+class MetricsRpsPerCode:
+    """Number of requests per second for all resources globally per code"""
+
+    additional_properties: dict[str, Any] = _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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        metrics_rps_per_code = cls()
+
+        metrics_rps_per_code.additional_properties = d
+        return metrics_rps_per_code
+
+    @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/model.py

@@ -6,7 +6,7 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.core_status import CoreStatus
+    from ..models.core_event import CoreEvent
     from ..models.environment_metadata import EnvironmentMetadata
     from ..models.model_spec import ModelSpec
 
@@ -19,32 +19,41 @@ class Model:
     """Logical object representing a model, that can be instantiated in multiple environments as model deployments
 
     Attributes:
+        events (Union[Unset, list['CoreEvent']]): Core events
         metadata (Union[Unset, EnvironmentMetadata]): Environment metadata
         spec (Union[Unset, ModelSpec]): Model specification
-        status (Union[Unset, CoreStatus]): Core status
+        status (Union[Unset, str]): Model status
     """
 
+    events: Union[Unset, list["CoreEvent"]] = UNSET
     metadata: Union[Unset, "EnvironmentMetadata"] = UNSET
     spec: Union[Unset, "ModelSpec"] = UNSET
-    status: Union[Unset, "CoreStatus"] = UNSET
+    status: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        events: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.events, Unset):
+            events = []
+            for componentsschemas_core_events_item_data in self.events:
+                componentsschemas_core_events_item = componentsschemas_core_events_item_data.to_dict()
+                events.append(componentsschemas_core_events_item)
+
         metadata: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.metadata, Unset):
+        if self.metadata and not isinstance(self.metadata, Unset):
             metadata = self.metadata.to_dict()
 
         spec: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.spec, Unset):
+        if self.spec and not isinstance(self.spec, Unset):
             spec = self.spec.to_dict()
 
-        status: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.status, Unset):
-            status = self.status.to_dict()
+        status = self.status
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if events is not UNSET:
+            field_dict["events"] = events
         if metadata is not UNSET:
             field_dict["metadata"] = metadata
         if spec is not UNSET:
@@ -56,13 +65,20 @@ class Model:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
-        from ..models.core_status import CoreStatus
+        from ..models.core_event import CoreEvent
         from ..models.environment_metadata import EnvironmentMetadata
         from ..models.model_spec import ModelSpec
 
         if not src_dict:
             return None
         d = src_dict.copy()
+        events = []
+        _events = d.pop("events", UNSET)
+        for componentsschemas_core_events_item_data in _events or []:
+            componentsschemas_core_events_item = CoreEvent.from_dict(componentsschemas_core_events_item_data)
+
+            events.append(componentsschemas_core_events_item)
+
         _metadata = d.pop("metadata", UNSET)
         metadata: Union[Unset, EnvironmentMetadata]
         if isinstance(_metadata, Unset):
@@ -77,14 +93,10 @@ class Model:
         else:
             spec = ModelSpec.from_dict(_spec)
 
-        _status = d.pop("status", UNSET)
-        status: Union[Unset, CoreStatus]
-        if isinstance(_status, Unset):
-            status = UNSET
-        else:
-            status = CoreStatus.from_dict(_status)
+        status = d.pop("status", UNSET)
 
         model = cls(
+            events=events,
             metadata=metadata,
             spec=spec,
             status=status,

beamlit/models/model_metadata.py

@@ -51,7 +51,7 @@ class ModelMetadata:
         display_name = self.display_name
 
         labels: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.labels, Unset):
+        if self.labels and not isinstance(self.labels, Unset):
             labels = self.labels.to_dict()
 
         name = self.name

beamlit/models/model_provider.py

@@ -56,13 +56,13 @@ class ModelProvider:
         comment = self.comment
 
         config: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.config, Unset):
+        if self.config and not isinstance(self.config, Unset):
             config = self.config.to_dict()
 
         display_name = self.display_name
 
         labels: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.labels, Unset):
+        if self.labels and not isinstance(self.labels, Unset):
             labels = self.labels.to_dict()
 
         name = self.name

beamlit/models/model_render.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ModelRender")
+
+
+@_attrs_define
+class ModelRender:
+    """ModelRender"""
+
+    additional_properties: dict[str, Any] = _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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        model_render = cls()
+
+        model_render.additional_properties = d
+        return model_render
+
+    @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/model_spec.py

@@ -30,8 +30,8 @@ class ModelSpec:
         policies (Union[Unset, list[str]]):
         private_clusters (Union[Unset, ModelPrivateCluster]): Private cluster where the model deployment is deployed
         runtime (Union[Unset, Runtime]): Set of configurations for a deployment
+        sandbox (Union[Unset, bool]): Sandbox mode
         serverless_config (Union[Unset, ServerlessConfig]): Configuration for a serverless deployment
-        model_provider (Union[Unset, str]): Model provider name
     """
 
     configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
@@ -42,13 +42,13 @@ class ModelSpec:
     policies: Union[Unset, list[str]] = UNSET
     private_clusters: Union[Unset, "ModelPrivateCluster"] = UNSET
     runtime: Union[Unset, "Runtime"] = UNSET
+    sandbox: Union[Unset, bool] = UNSET
     serverless_config: Union[Unset, "ServerlessConfig"] = UNSET
-    model_provider: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         configurations: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.configurations, Unset):
+        if self.configurations and not isinstance(self.configurations, Unset):
             configurations = self.configurations.to_dict()
 
         enabled = self.enabled
@@ -65,7 +65,7 @@ class ModelSpec:
             integration_connections = self.integration_connections
 
         pod_template: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.pod_template, Unset):
+        if self.pod_template and not isinstance(self.pod_template, Unset):
             pod_template = self.pod_template.to_dict()
 
         policies: Union[Unset, list[str]] = UNSET
@@ -73,19 +73,19 @@ class ModelSpec:
             policies = self.policies
 
         private_clusters: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.private_clusters, Unset):
+        if self.private_clusters and not isinstance(self.private_clusters, Unset):
             private_clusters = self.private_clusters.to_dict()
 
         runtime: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.runtime, Unset):
+        if self.runtime and not isinstance(self.runtime, Unset):
             runtime = self.runtime.to_dict()
 
+        sandbox = self.sandbox
+
         serverless_config: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.serverless_config, Unset):
+        if self.serverless_config and not isinstance(self.serverless_config, Unset):
             serverless_config = self.serverless_config.to_dict()
 
-        model_provider = self.model_provider
-
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
@@ -105,10 +105,10 @@ class ModelSpec:
             field_dict["privateClusters"] = private_clusters
         if runtime is not UNSET:
             field_dict["runtime"] = runtime
+        if sandbox is not UNSET:
+            field_dict["sandbox"] = sandbox
         if serverless_config is not UNSET:
             field_dict["serverlessConfig"] = serverless_config
-        if model_provider is not UNSET:
-            field_dict["modelProvider"] = model_provider
 
         return field_dict
 
@@ -165,6 +165,8 @@ class ModelSpec:
         else:
             runtime = Runtime.from_dict(_runtime)
 
+        sandbox = d.pop("sandbox", UNSET)
+
         _serverless_config = d.pop("serverlessConfig", UNSET)
         serverless_config: Union[Unset, ServerlessConfig]
         if isinstance(_serverless_config, Unset):
@@ -172,8 +174,6 @@ class ModelSpec:
         else:
             serverless_config = ServerlessConfig.from_dict(_serverless_config)
 
-        model_provider = d.pop("modelProvider", UNSET)
-
         model_spec = cls(
             configurations=configurations,
             enabled=enabled,
@@ -183,8 +183,8 @@ class ModelSpec:
             policies=policies,
             private_clusters=private_clusters,
             runtime=runtime,
+            sandbox=sandbox,
             serverless_config=serverless_config,
-            model_provider=model_provider,
         )
 
         model_spec.additional_properties = d

beamlit/models/pending_invitation_accept.py

@@ -29,7 +29,7 @@ class PendingInvitationAccept:
         email = self.email
 
         workspace: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.workspace, Unset):
+        if self.workspace and not isinstance(self.workspace, Unset):
             workspace = self.workspace.to_dict()
 
         field_dict: dict[str, Any] = {}

beamlit/models/pending_invitation_render.py

@@ -41,17 +41,17 @@ class PendingInvitationRender:
         invited_at = self.invited_at
 
         invited_by: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.invited_by, Unset):
+        if self.invited_by and not isinstance(self.invited_by, Unset):
             invited_by = self.invited_by.to_dict()
 
         role = self.role
 
         workspace: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.workspace, Unset):
+        if self.workspace and not isinstance(self.workspace, Unset):
             workspace = self.workspace.to_dict()
 
         workspace_details: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.workspace_details, Unset):
+        if self.workspace_details and not isinstance(self.workspace_details, Unset):
             workspace_details = self.workspace_details.to_dict()
 
         field_dict: dict[str, Any] = {}

beamlit/models/policy.py

@@ -28,11 +28,11 @@ class Policy:
 
     def to_dict(self) -> dict[str, Any]:
         metadata: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.metadata, Unset):
+        if self.metadata and not isinstance(self.metadata, Unset):
             metadata = self.metadata.to_dict()
 
         spec: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.spec, Unset):
+        if self.spec and not isinstance(self.spec, Unset):
             spec = self.spec.to_dict()
 
         field_dict: dict[str, Any] = {}

beamlit/models/provider_config.py

@@ -35,7 +35,7 @@ class ProviderConfig:
             presigned_url = self.presigned_url
 
         runtime: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.runtime, Unset):
+        if self.runtime and not isinstance(self.runtime, Unset):
             runtime = self.runtime.to_dict()
 
         field_dict: dict[str, Any] = {}

beamlit/models/repository.py

@@ -0,0 +1,70 @@
+from typing import Any, 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="Repository")
+
+
+@_attrs_define
+class Repository:
+    """Repository
+
+    Attributes:
+        type_ (Union[Unset, str]): Repository type
+        url (Union[Unset, str]): Repository URL
+    """
+
+    type_: Union[Unset, str] = UNSET
+    url: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        type_ = d.pop("type", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        repository = cls(
+            type_=type_,
+            url=url,
+        )
+
+        repository.additional_properties = d
+        return repository
+
+    @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/repository_type_0.py

@@ -0,0 +1,70 @@
+from typing import Any, 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="RepositoryType0")
+
+
+@_attrs_define
+class RepositoryType0:
+    """Repository
+
+    Attributes:
+        type_ (Union[Unset, str]): Repository type
+        url (Union[Unset, str]): Repository URL
+    """
+
+    type_: Union[Unset, str] = UNSET
+    url: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        type_ = d.pop("type", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        repository_type_0 = cls(
+            type_=type_,
+            url=url,
+        )
+
+        repository_type_0.additional_properties = d
+        return repository_type_0
+
+    @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/request_duration_over_time_metric.py

@@ -0,0 +1,97 @@
+from typing import Any, 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="RequestDurationOverTimeMetric")
+
+
+@_attrs_define
+class RequestDurationOverTimeMetric:
+    """Request duration over time metric
+
+    Attributes:
+        average (Union[Unset, float]): Average request duration
+        p50 (Union[Unset, float]): P50 request duration
+        p90 (Union[Unset, float]): P90 request duration
+        p99 (Union[Unset, float]): P99 request duration
+        timestamp (Union[Unset, str]): Timestamp
+    """
+
+    average: Union[Unset, float] = UNSET
+    p50: Union[Unset, float] = UNSET
+    p90: Union[Unset, float] = UNSET
+    p99: Union[Unset, float] = UNSET
+    timestamp: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        average = self.average
+
+        p50 = self.p50
+
+        p90 = self.p90
+
+        p99 = self.p99
+
+        timestamp = self.timestamp
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if average is not UNSET:
+            field_dict["average"] = average
+        if p50 is not UNSET:
+            field_dict["p50"] = p50
+        if p90 is not UNSET:
+            field_dict["p90"] = p90
+        if p99 is not UNSET:
+            field_dict["p99"] = p99
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        average = d.pop("average", UNSET)
+
+        p50 = d.pop("p50", UNSET)
+
+        p90 = d.pop("p90", UNSET)
+
+        p99 = d.pop("p99", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        request_duration_over_time_metric = cls(
+            average=average,
+            p50=p50,
+            p90=p90,
+            p99=p99,
+            timestamp=timestamp,
+        )
+
+        request_duration_over_time_metric.additional_properties = d
+        return request_duration_over_time_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