beamlit 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,58 @@
+from typing import Any, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="UpdateWorkspaceUserRoleBody")
+
+
+@_attrs_define
+class UpdateWorkspaceUserRoleBody:
+    """
+    Attributes:
+        role (str): The new role to assign to the user
+    """
+
+    role: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        role = d.pop("role")
+
+        update_workspace_user_role_body = cls(
+            role=role,
+        )
+
+        update_workspace_user_role_body.additional_properties = d
+        return update_workspace_user_role_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/workspace.py

@@ -0,0 +1,126 @@
+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.workspace_labels import WorkspaceLabels
+
+
+T = TypeVar("T", bound="Workspace")
+
+
+@_attrs_define
+class Workspace:
+    """Workspace
+
+    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
+        display_name (Union[Unset, str]): Workspace display name
+        labels (Union[Unset, WorkspaceLabels]): Workspace labels
+        name (Union[Unset, str]): Workspace name
+    """
+
+    created_at: Union[Unset, str] = UNSET
+    created_by: Union[Unset, str] = UNSET
+    updated_at: Union[Unset, str] = UNSET
+    updated_by: Union[Unset, str] = UNSET
+    display_name: Union[Unset, str] = UNSET
+    labels: Union[Unset, "WorkspaceLabels"] = UNSET
+    name: 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
+
+        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
+
+        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 display_name is not UNSET:
+            field_dict["display_name"] = display_name
+        if labels is not UNSET:
+            field_dict["labels"] = labels
+        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:
+        from ..models.workspace_labels import WorkspaceLabels
+
+        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)
+
+        display_name = d.pop("display_name", UNSET)
+
+        _labels = d.pop("labels", UNSET)
+        labels: Union[Unset, WorkspaceLabels]
+        if isinstance(_labels, Unset):
+            labels = UNSET
+        else:
+            labels = WorkspaceLabels.from_dict(_labels)
+
+        name = d.pop("name", UNSET)
+
+        workspace = cls(
+            created_at=created_at,
+            created_by=created_by,
+            updated_at=updated_at,
+            updated_by=updated_by,
+            display_name=display_name,
+            labels=labels,
+            name=name,
+        )
+
+        workspace.additional_properties = d
+        return workspace
+
+    @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/workspace_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="WorkspaceLabels")
+
+
+@_attrs_define
+class WorkspaceLabels:
+    """Workspace labels"""
+
+    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()
+        workspace_labels = cls()
+
+        workspace_labels.additional_properties = d
+        return workspace_labels
+
+    @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/workspace_user.py

@@ -0,0 +1,113 @@
+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="WorkspaceUser")
+
+
+@_attrs_define
+class WorkspaceUser:
+    """Workspace user
+
+    Attributes:
+        accepted (Union[Unset, bool]): Whether the user has accepted the workspace invitation
+        email (Union[Unset, str]): Workspace user email
+        email_verified (Union[Unset, bool]): Whether the user's email has been verified
+        family_name (Union[Unset, str]): Workspace user family name
+        given_name (Union[Unset, str]): Workspace user given name
+        role (Union[Unset, str]): Workspace user role
+        sub (Union[Unset, str]): Workspace user identifier
+    """
+
+    accepted: Union[Unset, bool] = UNSET
+    email: Union[Unset, str] = UNSET
+    email_verified: Union[Unset, bool] = UNSET
+    family_name: Union[Unset, str] = UNSET
+    given_name: Union[Unset, str] = UNSET
+    role: Union[Unset, str] = UNSET
+    sub: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        accepted = self.accepted
+
+        email = self.email
+
+        email_verified = self.email_verified
+
+        family_name = self.family_name
+
+        given_name = self.given_name
+
+        role = self.role
+
+        sub = self.sub
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if accepted is not UNSET:
+            field_dict["accepted"] = accepted
+        if email is not UNSET:
+            field_dict["email"] = email
+        if email_verified is not UNSET:
+            field_dict["email_verified"] = email_verified
+        if family_name is not UNSET:
+            field_dict["family_name"] = family_name
+        if given_name is not UNSET:
+            field_dict["given_name"] = given_name
+        if role is not UNSET:
+            field_dict["role"] = role
+        if sub is not UNSET:
+            field_dict["sub"] = sub
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        accepted = d.pop("accepted", UNSET)
+
+        email = d.pop("email", UNSET)
+
+        email_verified = d.pop("email_verified", UNSET)
+
+        family_name = d.pop("family_name", UNSET)
+
+        given_name = d.pop("given_name", UNSET)
+
+        role = d.pop("role", UNSET)
+
+        sub = d.pop("sub", UNSET)
+
+        workspace_user = cls(
+            accepted=accepted,
+            email=email,
+            email_verified=email_verified,
+            family_name=family_name,
+            given_name=given_name,
+            role=role,
+            sub=sub,
+        )
+
+        workspace_user.additional_properties = d
+        return workspace_user
+
+    @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/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

beamlit/types.py

@@ -0,0 +1,46 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import MutableMapping
+from http import HTTPStatus
+from typing import BinaryIO, Generic, Literal, Optional, TypeVar
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+FileJsonType = tuple[Optional[str], BinaryIO, Optional[str]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileJsonType:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileJsonType", "Response", "Unset"]

beamlit-0.1.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.3
+Name: beamlit
+Version: 0.1.0
+Summary: Add your description here
+Author-email: cploujoux <ch.ploujoux@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: attrs>=21.3.0
+Requires-Dist: httpx<0.28.0,>=0.20.0
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: pyyaml==6.0.2
+Description-Content-Type: text/markdown
+
+# beamlit
+A client library for accessing Beamlit Control Plane
+
+## Usage
+First, create a client:
+
+```python
+from beamlit.authentication import (RunClientWithCredentials, load_credentials,
+                                    new_client_with_credentials)
+
+WORKSPACE_NAME = "development"
+credentials = load_credentials(WORKSPACE_NAME)
+config = RunClientWithCredentials(
+    credentials=credentials,
+    workspace=WORKSPACE_NAME,
+)
+client = new_client_with_credentials(config)
+```
+
+Now call your endpoint and use your models:
+
+```python
+from typing import List
+
+from beamlit.api.models import list_models
+from beamlit.types import Response
+from beamlit.models.model import Model
+
+with client as client:
+    models: List[Model] = list_models.sync(client=client)
+    # or if you need more info (e.g. status_code)
+    response: Response[List[Model]] = list_models.sync_detailed(client=client)
+```
+
+Or do the same thing with an async version:
+
+```python
+from typing import List
+
+from beamlit.api.models import list_models
+from beamlit.types import Response
+from beamlit.models.model import Model
+
+async with client as client:
+    models: List[Model] = await list_models.asyncio(client=client)
+    response: Response[List[Model]] = await list_models.asyncio_detailed(client=client)
+```