blaxel 0.64.0__py3-none-any.whl

blaxel/models/pending_invitation_render.py

@@ -0,0 +1,147 @@
+from typing import TYPE_CHECKING, Any, 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.pending_invitation_render_invited_by import PendingInvitationRenderInvitedBy
+    from ..models.pending_invitation_render_workspace import PendingInvitationRenderWorkspace
+    from ..models.pending_invitation_workspace_details import PendingInvitationWorkspaceDetails
+
+
+T = TypeVar("T", bound="PendingInvitationRender")
+
+
+@_attrs_define
+class PendingInvitationRender:
+    """Pending invitation in workspace
+
+    Attributes:
+        email (Union[Unset, str]): User email
+        invited_at (Union[Unset, str]): Invitation date
+        invited_by (Union[Unset, PendingInvitationRenderInvitedBy]): Invited by
+        role (Union[Unset, str]): ACL role
+        workspace (Union[Unset, PendingInvitationRenderWorkspace]): Workspace
+        workspace_details (Union[Unset, PendingInvitationWorkspaceDetails]): Workspace details
+    """
+
+    email: Union[Unset, str] = UNSET
+    invited_at: Union[Unset, str] = UNSET
+    invited_by: Union[Unset, "PendingInvitationRenderInvitedBy"] = UNSET
+    role: Union[Unset, str] = UNSET
+    workspace: Union[Unset, "PendingInvitationRenderWorkspace"] = UNSET
+    workspace_details: Union[Unset, "PendingInvitationWorkspaceDetails"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        email = self.email
+
+        invited_at = self.invited_at
+
+        invited_by: Union[Unset, dict[str, Any]] = UNSET
+        if self.invited_by and not isinstance(self.invited_by, Unset) and not isinstance(self.invited_by, dict):
+            invited_by = self.invited_by.to_dict()
+        elif self.invited_by and isinstance(self.invited_by, dict):
+            invited_by = self.invited_by
+
+        role = self.role
+
+        workspace: Union[Unset, dict[str, Any]] = UNSET
+        if self.workspace and not isinstance(self.workspace, Unset) and not isinstance(self.workspace, dict):
+            workspace = self.workspace.to_dict()
+        elif self.workspace and isinstance(self.workspace, dict):
+            workspace = self.workspace
+
+        workspace_details: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.workspace_details
+            and not isinstance(self.workspace_details, Unset)
+            and not isinstance(self.workspace_details, dict)
+        ):
+            workspace_details = self.workspace_details.to_dict()
+        elif self.workspace_details and isinstance(self.workspace_details, dict):
+            workspace_details = self.workspace_details
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if email is not UNSET:
+            field_dict["email"] = email
+        if invited_at is not UNSET:
+            field_dict["invitedAt"] = invited_at
+        if invited_by is not UNSET:
+            field_dict["invitedBy"] = invited_by
+        if role is not UNSET:
+            field_dict["role"] = role
+        if workspace is not UNSET:
+            field_dict["workspace"] = workspace
+        if workspace_details is not UNSET:
+            field_dict["workspaceDetails"] = workspace_details
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.pending_invitation_render_invited_by import PendingInvitationRenderInvitedBy
+        from ..models.pending_invitation_render_workspace import PendingInvitationRenderWorkspace
+        from ..models.pending_invitation_workspace_details import PendingInvitationWorkspaceDetails
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        email = d.pop("email", UNSET)
+
+        invited_at = d.pop("invitedAt", UNSET)
+
+        _invited_by = d.pop("invitedBy", UNSET)
+        invited_by: Union[Unset, PendingInvitationRenderInvitedBy]
+        if isinstance(_invited_by, Unset):
+            invited_by = UNSET
+        else:
+            invited_by = PendingInvitationRenderInvitedBy.from_dict(_invited_by)
+
+        role = d.pop("role", UNSET)
+
+        _workspace = d.pop("workspace", UNSET)
+        workspace: Union[Unset, PendingInvitationRenderWorkspace]
+        if isinstance(_workspace, Unset):
+            workspace = UNSET
+        else:
+            workspace = PendingInvitationRenderWorkspace.from_dict(_workspace)
+
+        _workspace_details = d.pop("workspaceDetails", UNSET)
+        workspace_details: Union[Unset, PendingInvitationWorkspaceDetails]
+        if isinstance(_workspace_details, Unset):
+            workspace_details = UNSET
+        else:
+            workspace_details = PendingInvitationWorkspaceDetails.from_dict(_workspace_details)
+
+        pending_invitation_render = cls(
+            email=email,
+            invited_at=invited_at,
+            invited_by=invited_by,
+            role=role,
+            workspace=workspace,
+            workspace_details=workspace_details,
+        )
+
+        pending_invitation_render.additional_properties = d
+        return pending_invitation_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

blaxel/models/pending_invitation_render_invited_by.py

@@ -0,0 +1,88 @@
+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="PendingInvitationRenderInvitedBy")
+
+
+@_attrs_define
+class PendingInvitationRenderInvitedBy:
+    """Invited by
+
+    Attributes:
+        email (Union[Unset, str]): User email
+        family_name (Union[Unset, str]): User family name
+        given_name (Union[Unset, str]): User given name
+        sub (Union[Unset, str]): User sub
+    """
+
+    email: Union[Unset, str] = UNSET
+    family_name: Union[Unset, str] = UNSET
+    given_name: 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]:
+        email = self.email
+
+        family_name = self.family_name
+
+        given_name = self.given_name
+
+        sub = self.sub
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if email is not UNSET:
+            field_dict["email"] = email
+        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 sub is not UNSET:
+            field_dict["sub"] = sub
+
+        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()
+        email = d.pop("email", UNSET)
+
+        family_name = d.pop("family_name", UNSET)
+
+        given_name = d.pop("given_name", UNSET)
+
+        sub = d.pop("sub", UNSET)
+
+        pending_invitation_render_invited_by = cls(
+            email=email,
+            family_name=family_name,
+            given_name=given_name,
+            sub=sub,
+        )
+
+        pending_invitation_render_invited_by.additional_properties = d
+        return pending_invitation_render_invited_by
+
+    @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

blaxel/models/pending_invitation_render_workspace.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="PendingInvitationRenderWorkspace")
+
+
+@_attrs_define
+class PendingInvitationRenderWorkspace:
+    """Workspace
+
+    Attributes:
+        display_name (Union[Unset, str]): Workspace display name
+        name (Union[Unset, str]): Workspace name
+    """
+
+    display_name: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        display_name = self.display_name
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if display_name is not UNSET:
+            field_dict["displayName"] = display_name
+        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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        display_name = d.pop("displayName", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        pending_invitation_render_workspace = cls(
+            display_name=display_name,
+            name=name,
+        )
+
+        pending_invitation_render_workspace.additional_properties = d
+        return pending_invitation_render_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

blaxel/models/pending_invitation_workspace_details.py

@@ -0,0 +1,72 @@
+from typing import Any, 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="PendingInvitationWorkspaceDetails")
+
+
+@_attrs_define
+class PendingInvitationWorkspaceDetails:
+    """Workspace details
+
+    Attributes:
+        emails (Union[Unset, list[Any]]): List of user emails in the workspace
+        user_number (Union[Unset, float]): Number of users in the workspace
+    """
+
+    emails: Union[Unset, list[Any]] = UNSET
+    user_number: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        emails: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.emails, Unset):
+            emails = self.emails
+
+        user_number = self.user_number
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if emails is not UNSET:
+            field_dict["emails"] = emails
+        if user_number is not UNSET:
+            field_dict["user_number"] = user_number
+
+        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()
+        emails = cast(list[Any], d.pop("emails", UNSET))
+
+        user_number = d.pop("user_number", UNSET)
+
+        pending_invitation_workspace_details = cls(
+            emails=emails,
+            user_number=user_number,
+        )
+
+        pending_invitation_workspace_details.additional_properties = d
+        return pending_invitation_workspace_details
+
+    @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

blaxel/models/pod_template_spec.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="PodTemplateSpec")
+
+
+@_attrs_define
+class PodTemplateSpec:
+    """Pod template specification"""
+
+    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()
+        pod_template_spec = cls()
+
+        pod_template_spec.additional_properties = d
+        return pod_template_spec
+
+    @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

blaxel/models/policy.py

@@ -0,0 +1,96 @@
+from typing import TYPE_CHECKING, Any, 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 import Metadata
+    from ..models.policy_spec import PolicySpec
+
+
+T = TypeVar("T", bound="Policy")
+
+
+@_attrs_define
+class Policy:
+    """Rule that controls how a deployment is made and served (e.g. location restrictions)
+
+    Attributes:
+        metadata (Union[Unset, Metadata]): Metadata
+        spec (Union[Unset, PolicySpec]): Policy specification
+    """
+
+    metadata: Union[Unset, "Metadata"] = UNSET
+    spec: Union[Unset, "PolicySpec"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        metadata: Union[Unset, dict[str, Any]] = UNSET
+        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+            metadata = self.metadata.to_dict()
+        elif self.metadata and isinstance(self.metadata, dict):
+            metadata = self.metadata
+
+        spec: Union[Unset, dict[str, Any]] = UNSET
+        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
+            spec = self.spec.to_dict()
+        elif self.spec and isinstance(self.spec, dict):
+            spec = self.spec
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if spec is not UNSET:
+            field_dict["spec"] = spec
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.metadata import Metadata
+        from ..models.policy_spec import PolicySpec
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        _spec = d.pop("spec", UNSET)
+        spec: Union[Unset, PolicySpec]
+        if isinstance(_spec, Unset):
+            spec = UNSET
+        else:
+            spec = PolicySpec.from_dict(_spec)
+
+        policy = cls(
+            metadata=metadata,
+            spec=spec,
+        )
+
+        policy.additional_properties = d
+        return policy
+
+    @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

blaxel/models/policy_location.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="PolicyLocation")
+
+
+@_attrs_define
+class PolicyLocation:
+    """Policy location
+
+    Attributes:
+        name (Union[Unset, str]): Policy location name
+        type_ (Union[Unset, str]): Policy location type
+    """
+
+    name: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        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:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        name = d.pop("name", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        policy_location = cls(
+            name=name,
+            type_=type_,
+        )
+
+        policy_location.additional_properties = d
+        return policy_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

blaxel/models/policy_max_tokens.py

@@ -0,0 +1,106 @@
+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="PolicyMaxTokens")
+
+
+@_attrs_define
+class PolicyMaxTokens:
+    """PolicyMaxTokens is a local type that wraps a slice of PolicyMaxTokens
+
+    Attributes:
+        granularity (Union[Unset, str]): Granularity
+        input_ (Union[Unset, int]): Input
+        output (Union[Unset, int]): Output
+        ratio_input_over_output (Union[Unset, int]): RatioInputOverOutput
+        step (Union[Unset, int]): Step
+        total (Union[Unset, int]): Total
+    """
+
+    granularity: Union[Unset, str] = UNSET
+    input_: Union[Unset, int] = UNSET
+    output: Union[Unset, int] = UNSET
+    ratio_input_over_output: Union[Unset, int] = UNSET
+    step: Union[Unset, int] = UNSET
+    total: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        granularity = self.granularity
+
+        input_ = self.input_
+
+        output = self.output
+
+        ratio_input_over_output = self.ratio_input_over_output
+
+        step = self.step
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if granularity is not UNSET:
+            field_dict["granularity"] = granularity
+        if input_ is not UNSET:
+            field_dict["input"] = input_
+        if output is not UNSET:
+            field_dict["output"] = output
+        if ratio_input_over_output is not UNSET:
+            field_dict["ratioInputOverOutput"] = ratio_input_over_output
+        if step is not UNSET:
+            field_dict["step"] = step
+        if total is not UNSET:
+            field_dict["total"] = total
+
+        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()
+        granularity = d.pop("granularity", UNSET)
+
+        input_ = d.pop("input", UNSET)
+
+        output = d.pop("output", UNSET)
+
+        ratio_input_over_output = d.pop("ratioInputOverOutput", UNSET)
+
+        step = d.pop("step", UNSET)
+
+        total = d.pop("total", UNSET)
+
+        policy_max_tokens = cls(
+            granularity=granularity,
+            input_=input_,
+            output=output,
+            ratio_input_over_output=ratio_input_over_output,
+            step=step,
+            total=total,
+        )
+
+        policy_max_tokens.additional_properties = d
+        return policy_max_tokens
+
+    @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