beamlit 0.0.20rc2__py3-none-any.whl → 0.0.20rc4__py3-none-any.whl

beamlit/models/agent_deployment_history_event.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union, cast
+from typing import Any, Type, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -13,64 +13,44 @@ class AgentDeploymentHistoryEvent:
     """Agent deployment history event
 
     Attributes:
-        end (Union[None, Unset, str]): End time
-        error (Union[None, Unset, str]): Error message
+        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[None, Unset, str]): Start time
+        start (Union[Unset, str]): Start time
         status (Union[Unset, str]): Status, eg: running, success, failed
-        sub_function (Union[None, Unset, str]): Function used in kit if a kit was used
-        took (Union[None, Unset, int]): Number of milliseconds it took to complete the event
+        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[None, Unset, str] = UNSET
-    error: Union[None, Unset, str] = UNSET
+    end: Union[Unset, str] = UNSET
+    error: Union[Unset, str] = UNSET
     name: Union[Unset, str] = UNSET
     parameters: Union[Unset, str] = UNSET
-    start: Union[None, Unset, str] = UNSET
+    start: Union[Unset, str] = UNSET
     status: Union[Unset, str] = UNSET
-    sub_function: Union[None, Unset, str] = UNSET
-    took: Union[None, Unset, int] = 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: Union[None, Unset, str]
-        if isinstance(self.end, Unset):
-            end = UNSET
-        else:
-            end = self.end
-
-        error: Union[None, Unset, str]
-        if isinstance(self.error, Unset):
-            error = UNSET
-        else:
-            error = self.error
+        end = self.end
+
+        error = self.error
 
         name = self.name
 
         parameters = self.parameters
 
-        start: Union[None, Unset, str]
-        if isinstance(self.start, Unset):
-            start = UNSET
-        else:
-            start = self.start
+        start = self.start
 
         status = self.status
 
-        sub_function: Union[None, Unset, str]
-        if isinstance(self.sub_function, Unset):
-            sub_function = UNSET
-        else:
-            sub_function = self.sub_function
+        sub_function = self.sub_function
 
-        took: Union[None, Unset, int]
-        if isinstance(self.took, Unset):
-            took = UNSET
-        else:
-            took = self.took
+        took = self.took
 
         type = self.type
 
@@ -100,58 +80,24 @@ class AgentDeploymentHistoryEvent:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
+        end = d.pop("end", UNSET)
 
-        def _parse_end(data: object) -> Union[None, Unset, str]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, str], data)
-
-        end = _parse_end(d.pop("end", UNSET))
-
-        def _parse_error(data: object) -> Union[None, Unset, str]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, str], data)
-
-        error = _parse_error(d.pop("error", UNSET))
+        error = d.pop("error", UNSET)
 
         name = d.pop("name", UNSET)
 
         parameters = d.pop("parameters", UNSET)
 
-        def _parse_start(data: object) -> Union[None, Unset, str]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, str], data)
-
-        start = _parse_start(d.pop("start", UNSET))
+        start = d.pop("start", UNSET)
 
         status = d.pop("status", UNSET)
 
-        def _parse_sub_function(data: object) -> Union[None, Unset, str]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, str], data)
-
-        sub_function = _parse_sub_function(d.pop("sub_function", UNSET))
-
-        def _parse_took(data: object) -> Union[None, Unset, int]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, int], data)
+        sub_function = d.pop("sub_function", UNSET)
 
-        took = _parse_took(d.pop("took", UNSET))
+        took = d.pop("took", UNSET)
 
         type = d.pop("type", UNSET)
 

beamlit/models/agent_deployment_pod_template.py

@@ -0,0 +1,45 @@
+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:
+        if not src_dict:
+            return None
+        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_history.py

@@ -0,0 +1,165 @@
+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_history_event import AgentHistoryEvent
+
+
+T = TypeVar("T", bound="AgentHistory")
+
+
+@_attrs_define
+class AgentHistory:
+    """Agent deployment history
+
+    Attributes:
+        created_at (Union[Unset, str]): The date and time when the resource was created
+        updated_at (Union[Unset, str]): The date and time when the resource was updated
+        agent (Union[Unset, str]): Agent name
+        end (Union[Unset, str]): End time
+        environment (Union[Unset, str]): Environment name
+        events (Union[Unset, List['AgentHistoryEvent']]): 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
+    updated_at: Union[Unset, str] = UNSET
+    agent: Union[Unset, str] = UNSET
+    end: Union[Unset, str] = UNSET
+    environment: Union[Unset, str] = UNSET
+    events: Union[Unset, List["AgentHistoryEvent"]] = 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
+
+        updated_at = self.updated_at
+
+        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["createdAt"] = created_at
+        if updated_at is not UNSET:
+            field_dict["updatedAt"] = updated_at
+        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_history_event import AgentHistoryEvent
+
+        d = src_dict.copy()
+        created_at = d.pop("createdAt", UNSET)
+
+        updated_at = d.pop("updatedAt", 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 = AgentHistoryEvent.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_history = cls(
+            created_at=created_at,
+            updated_at=updated_at,
+            agent=agent,
+            end=end,
+            environment=environment,
+            events=events,
+            request_id=request_id,
+            start=start,
+            status=status,
+            took=took,
+            workspace=workspace,
+        )
+
+        agent_history.additional_properties = d
+        return agent_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_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="AgentHistoryEvent")
+
+
+@_attrs_define
+class AgentHistoryEvent:
+    """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_history_event = cls(
+            end=end,
+            error=error,
+            name=name,
+            parameters=parameters,
+            start=start,
+            status=status,
+            sub_function=sub_function,
+            took=took,
+            type=type,
+        )
+
+        agent_history_event.additional_properties = d
+        return agent_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_metadata.py

@@ -0,0 +1,144 @@
+from typing import TYPE_CHECKING, Any, Dict, 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.metadata_labels import MetadataLabels
+
+
+T = TypeVar("T", bound="AgentMetadata")
+
+
+@_attrs_define
+class AgentMetadata:
+    """Agent metadata
+
+    Attributes:
+        created_at (Union[Unset, str]): The date and time when the resource was created
+        updated_at (Union[Unset, str]): The date and time when the resource was updated
+        created_by (Union[Unset, str]): The user or service account who created the resource
+        updated_by (Union[Unset, str]): The user or service account who updated the resource
+        display_name (Union[Unset, str]): Model display name
+        labels (Union[Unset, MetadataLabels]): Labels
+        name (Union[Unset, str]): Model name
+        workspace (Union[Unset, str]): Workspace name
+        environment (Union[Unset, str]): Environment name
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    created_by: Union[Unset, str] = UNSET
+    updated_by: Union[Unset, str] = UNSET
+    display_name: Union[Unset, str] = UNSET
+    labels: Union[Unset, "MetadataLabels"] = UNSET
+    name: Union[Unset, str] = UNSET
+    workspace: Union[Unset, str] = UNSET
+    environment: 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
+
+        updated_at = self.updated_at
+
+        created_by = self.created_by
+
+        updated_by = self.updated_by
+
+        display_name = self.display_name
+
+        labels: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.labels, Unset):
+            labels = self.labels.to_dict()
+
+        name = self.name
+
+        workspace = self.workspace
+
+        environment = self.environment
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if created_at is not UNSET:
+            field_dict["createdAt"] = created_at
+        if updated_at is not UNSET:
+            field_dict["updatedAt"] = updated_at
+        if created_by is not UNSET:
+            field_dict["createdBy"] = created_by
+        if updated_by is not UNSET:
+            field_dict["updatedBy"] = updated_by
+        if display_name is not UNSET:
+            field_dict["displayName"] = display_name
+        if labels is not UNSET:
+            field_dict["labels"] = labels
+        if name is not UNSET:
+            field_dict["name"] = name
+        if workspace is not UNSET:
+            field_dict["workspace"] = workspace
+        if environment is not UNSET:
+            field_dict["environment"] = environment
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.metadata_labels import MetadataLabels
+
+        d = src_dict.copy()
+        created_at = d.pop("createdAt", UNSET)
+
+        updated_at = d.pop("updatedAt", UNSET)
+
+        created_by = d.pop("createdBy", UNSET)
+
+        updated_by = d.pop("updatedBy", UNSET)
+
+        display_name = d.pop("displayName", UNSET)
+
+        _labels = d.pop("labels", UNSET)
+        labels: Union[Unset, MetadataLabels]
+        if isinstance(_labels, Unset):
+            labels = UNSET
+        else:
+            labels = MetadataLabels.from_dict(_labels)
+
+        name = d.pop("name", UNSET)
+
+        workspace = d.pop("workspace", UNSET)
+
+        environment = d.pop("environment", UNSET)
+
+        agent_metadata = cls(
+            created_at=created_at,
+            updated_at=updated_at,
+            created_by=created_by,
+            updated_by=updated_by,
+            display_name=display_name,
+            labels=labels,
+            name=name,
+            workspace=workspace,
+            environment=environment,
+        )
+
+        agent_metadata.additional_properties = d
+        return agent_metadata
+
+    @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

@@ -38,6 +38,8 @@ class AgentRelease:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         from_ = d.pop("from", UNSET)