beamlit 0.1.0__py3-none-any.whl

beamlit/models/agent_deployment_history.py

@@ -0,0 +1,183 @@
+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.agent_deployment_history_event import AgentDeploymentHistoryEvent
+
+
+T = TypeVar("T", bound="AgentDeploymentHistory")
+
+
+@_attrs_define
+class AgentDeploymentHistory:
+    """Agent deployment history
+
+    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
+        agent (Union[Unset, str]): Agent name
+        end (Union[Unset, str]): End time
+        environment (Union[Unset, str]): Environment name
+        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
+        took (Union[Unset, int]): Number of milliseconds it took to complete the event
+        workspace (Union[Unset, str]): The workspace the agent deployment belongs to
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    created_by: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    updated_by: Union[Unset, str] = UNSET
+    agent: Union[Unset, str] = UNSET
+    end: Union[Unset, str] = UNSET
+    environment: Union[Unset, str] = UNSET
+    events: Union[Unset, List["AgentDeploymentHistoryEvent"]] = UNSET
+    request_id: Union[Unset, str] = UNSET
+    start: Union[Unset, str] = UNSET
+    status: Union[Unset, str] = UNSET
+    took: Union[Unset, int] = 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
+
+        agent = self.agent
+
+        end = self.end
+
+        environment = self.environment
+
+        events: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.events, Unset):
+            events = []
+            for events_item_data in self.events:
+                events_item = events_item_data.to_dict()
+                events.append(events_item)
+
+        request_id = self.request_id
+
+        start = self.start
+
+        status = self.status
+
+        took = self.took
+
+        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 agent is not UNSET:
+            field_dict["agent"] = agent
+        if end is not UNSET:
+            field_dict["end"] = end
+        if environment is not UNSET:
+            field_dict["environment"] = environment
+        if events is not UNSET:
+            field_dict["events"] = events
+        if request_id is not UNSET:
+            field_dict["request_id"] = request_id
+        if start is not UNSET:
+            field_dict["start"] = start
+        if status is not UNSET:
+            field_dict["status"] = status
+        if took is not UNSET:
+            field_dict["took"] = took
+        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:
+        from ..models.agent_deployment_history_event import AgentDeploymentHistoryEvent
+
+        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)
+
+        agent = d.pop("agent", UNSET)
+
+        end = d.pop("end", UNSET)
+
+        environment = d.pop("environment", UNSET)
+
+        events = []
+        _events = d.pop("events", UNSET)
+        for events_item_data in _events or []:
+            events_item = AgentDeploymentHistoryEvent.from_dict(events_item_data)
+
+            events.append(events_item)
+
+        request_id = d.pop("request_id", UNSET)
+
+        start = d.pop("start", UNSET)
+
+        status = d.pop("status", UNSET)
+
+        took = d.pop("took", UNSET)
+
+        workspace = d.pop("workspace", UNSET)
+
+        agent_deployment_history = cls(
+            created_at=created_at,
+            created_by=created_by,
+            updated_at=updated_at,
+            updated_by=updated_by,
+            agent=agent,
+            end=end,
+            environment=environment,
+            events=events,
+            request_id=request_id,
+            start=start,
+            status=status,
+            took=took,
+            workspace=workspace,
+        )
+
+        agent_deployment_history.additional_properties = d
+        return agent_deployment_history
+
+    @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/agent_deployment_history_event.py

@@ -0,0 +1,131 @@
+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="AgentDeploymentHistoryEvent")
+
+
+@_attrs_define
+class AgentDeploymentHistoryEvent:
+    """Agent deployment history event
+
+    Attributes:
+        end (Union[Unset, str]): End time
+        error (Union[Unset, str]): Error message
+        name (Union[Unset, str]): Name of the function or agent
+        parameters (Union[Unset, str]): Parameters
+        start (Union[Unset, str]): Start time
+        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
+    """
+
+    end: Union[Unset, str] = UNSET
+    error: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    parameters: Union[Unset, str] = UNSET
+    start: Union[Unset, str] = UNSET
+    status: Union[Unset, str] = UNSET
+    sub_function: Union[Unset, str] = UNSET
+    took: Union[Unset, int] = UNSET
+    type: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        end = self.end
+
+        error = self.error
+
+        name = self.name
+
+        parameters = self.parameters
+
+        start = self.start
+
+        status = self.status
+
+        sub_function = self.sub_function
+
+        took = self.took
+
+        type = self.type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if end is not UNSET:
+            field_dict["end"] = end
+        if error is not UNSET:
+            field_dict["error"] = error
+        if name is not UNSET:
+            field_dict["name"] = name
+        if parameters is not UNSET:
+            field_dict["parameters"] = parameters
+        if start is not UNSET:
+            field_dict["start"] = start
+        if status is not UNSET:
+            field_dict["status"] = status
+        if sub_function is not UNSET:
+            field_dict["sub_function"] = sub_function
+        if took is not UNSET:
+            field_dict["took"] = took
+        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:
+        d = src_dict.copy()
+        end = d.pop("end", UNSET)
+
+        error = d.pop("error", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        parameters = d.pop("parameters", UNSET)
+
+        start = d.pop("start", UNSET)
+
+        status = d.pop("status", UNSET)
+
+        sub_function = d.pop("sub_function", UNSET)
+
+        took = d.pop("took", UNSET)
+
+        type = d.pop("type", UNSET)
+
+        agent_deployment_history_event = cls(
+            end=end,
+            error=error,
+            name=name,
+            parameters=parameters,
+            start=start,
+            status=status,
+            sub_function=sub_function,
+            took=took,
+            type=type,
+        )
+
+        agent_deployment_history_event.additional_properties = d
+        return agent_deployment_history_event
+
+    @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/agent_deployment_pod_template.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="AgentDeploymentPodTemplate")
+
+
+@_attrs_define
+class AgentDeploymentPodTemplate:
+    """The pod template, should be a valid Kubernetes pod template"""
+
+    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:
+        d = src_dict.copy()
+        agent_deployment_pod_template = cls()
+
+        agent_deployment_pod_template.additional_properties = d
+        return agent_deployment_pod_template
+
+    @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/agent_release.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="AgentRelease")
+
+
+@_attrs_define
+class AgentRelease:
+    """Agent release, used to deploy a agent from one environment to another
+
+    Attributes:
+        from_ (Union[Unset, str]): Origin environment from which the agent is released
+        to (Union[Unset, str]): Destination environment to which the agent is released
+    """
+
+    from_: Union[Unset, str] = UNSET
+    to: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from_ = self.from_
+
+        to = self.to
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if from_ is not UNSET:
+            field_dict["from"] = from_
+        if to is not UNSET:
+            field_dict["to"] = to
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        from_ = d.pop("from", UNSET)
+
+        to = d.pop("to", UNSET)
+
+        agent_release = cls(
+            from_=from_,
+            to=to,
+        )
+
+        agent_release.additional_properties = d
+        return agent_release
+
+    @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/api_key.py

@@ -0,0 +1,140 @@
+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="ApiKey")
+
+
+@_attrs_define
+class ApiKey:
+    """Long-lived API key for accessing Beamlit
+
+    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
+        api_key (Union[Unset, str]): Api key
+        expires_in (Union[Unset, str]): Duration until expiration (in seconds)
+        id (Union[Unset, str]): Api key id, to retrieve it from the API
+        name (Union[Unset, str]): Name for the API key
+        sub (Union[Unset, str]): User subject identifier
+        sub_type (Union[Unset, str]): Subject type
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    created_by: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    updated_by: Union[Unset, str] = UNSET
+    api_key: Union[Unset, str] = UNSET
+    expires_in: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    sub: Union[Unset, str] = UNSET
+    sub_type: 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
+
+        api_key = self.api_key
+
+        expires_in = self.expires_in
+
+        id = self.id
+
+        name = self.name
+
+        sub = self.sub
+
+        sub_type = self.sub_type
+
+        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 api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if expires_in is not UNSET:
+            field_dict["expires_in"] = expires_in
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if sub is not UNSET:
+            field_dict["sub"] = sub
+        if sub_type is not UNSET:
+            field_dict["sub_type"] = sub_type
+
+        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)
+
+        api_key = d.pop("api_key", UNSET)
+
+        expires_in = d.pop("expires_in", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        sub = d.pop("sub", UNSET)
+
+        sub_type = d.pop("sub_type", UNSET)
+
+        api_key = cls(
+            created_at=created_at,
+            created_by=created_by,
+            updated_at=updated_at,
+            updated_by=updated_by,
+            api_key=api_key,
+            expires_in=expires_in,
+            id=id,
+            name=name,
+            sub=sub,
+            sub_type=sub_type,
+        )
+
+        api_key.additional_properties = d
+        return api_key
+
+    @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/authentication_provider_model.py

@@ -0,0 +1,142 @@
+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="AuthenticationProviderModel")
+
+
+@_attrs_define
+class AuthenticationProviderModel:
+    """Model obtained from an external authentication provider, such as HuggingFace, OpenAI, etc...
+
+    Attributes:
+        created_at (Union[Unset, str]): Provider model created at
+        downloads (Union[Unset, int]): Provider model downloads
+        id (Union[Unset, str]): Provider model ID
+        library_name (Union[Unset, str]): Provider model library name
+        likes (Union[Unset, int]): Provider model likes
+        name (Union[Unset, str]): Provider model name
+        pipeline_tag (Union[Unset, str]): Provider model pipeline tag
+        private (Union[Unset, bool]): Provider model private
+        tags (Union[Unset, List[str]]): Provider model tags
+        trending_score (Union[Unset, int]): Provider model trending score
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    downloads: Union[Unset, int] = UNSET
+    id: Union[Unset, str] = UNSET
+    library_name: Union[Unset, str] = UNSET
+    likes: Union[Unset, int] = UNSET
+    name: Union[Unset, str] = UNSET
+    pipeline_tag: Union[Unset, str] = UNSET
+    private: Union[Unset, bool] = UNSET
+    tags: Union[Unset, List[str]] = UNSET
+    trending_score: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at
+
+        downloads = self.downloads
+
+        id = self.id
+
+        library_name = self.library_name
+
+        likes = self.likes
+
+        name = self.name
+
+        pipeline_tag = self.pipeline_tag
+
+        private = self.private
+
+        tags: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags
+
+        trending_score = self.trending_score
+
+        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 downloads is not UNSET:
+            field_dict["downloads"] = downloads
+        if id is not UNSET:
+            field_dict["id"] = id
+        if library_name is not UNSET:
+            field_dict["library_name"] = library_name
+        if likes is not UNSET:
+            field_dict["likes"] = likes
+        if name is not UNSET:
+            field_dict["name"] = name
+        if pipeline_tag is not UNSET:
+            field_dict["pipeline_tag"] = pipeline_tag
+        if private is not UNSET:
+            field_dict["private"] = private
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+        if trending_score is not UNSET:
+            field_dict["trending_score"] = trending_score
+
+        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)
+
+        downloads = d.pop("downloads", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        library_name = d.pop("library_name", UNSET)
+
+        likes = d.pop("likes", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        pipeline_tag = d.pop("pipeline_tag", UNSET)
+
+        private = d.pop("private", UNSET)
+
+        tags = cast(List[str], d.pop("tags", UNSET))
+
+        trending_score = d.pop("trending_score", UNSET)
+
+        authentication_provider_model = cls(
+            created_at=created_at,
+            downloads=downloads,
+            id=id,
+            library_name=library_name,
+            likes=likes,
+            name=name,
+            pipeline_tag=pipeline_tag,
+            private=private,
+            tags=tags,
+            trending_score=trending_score,
+        )
+
+        authentication_provider_model.additional_properties = d
+        return authentication_provider_model
+
+    @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