robosystems-client 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

robosystems_client/models/invite_member_request.py

@@ -0,0 +1,93 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.org_role import OrgRole
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InviteMemberRequest")
+
+
+@_attrs_define
+class InviteMemberRequest:
+  """Request to invite a member to an organization.
+
+  Attributes:
+      email (str):
+      role (Union[None, OrgRole, Unset]):  Default: OrgRole.MEMBER.
+  """
+
+  email: str
+  role: Union[None, OrgRole, Unset] = OrgRole.MEMBER
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    email = self.email
+
+    role: Union[None, Unset, str]
+    if isinstance(self.role, Unset):
+      role = UNSET
+    elif isinstance(self.role, OrgRole):
+      role = self.role.value
+    else:
+      role = self.role
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "email": email,
+      }
+    )
+    if role is not UNSET:
+      field_dict["role"] = role
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    email = d.pop("email")
+
+    def _parse_role(data: object) -> Union[None, OrgRole, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        role_type_0 = OrgRole(data)
+
+        return role_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, OrgRole, Unset], data)
+
+    role = _parse_role(d.pop("role", UNSET))
+
+    invite_member_request = cls(
+      email=email,
+      role=role,
+    )
+
+    invite_member_request.additional_properties = d
+    return invite_member_request
+
+  @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

robosystems_client/models/list_org_graphs_response_200_item.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ListOrgGraphsResponse200Item")
+
+
+@_attrs_define
+class ListOrgGraphsResponse200Item:
+  """ """
+
+  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: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    list_org_graphs_response_200_item = cls()
+
+    list_org_graphs_response_200_item.additional_properties = d
+    return list_org_graphs_response_200_item
+
+  @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

robosystems_client/models/org_detail_response.py

@@ -0,0 +1,174 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.org_role import OrgRole
+from ..models.org_type import OrgType
+
+if TYPE_CHECKING:
+  from ..models.org_detail_response_graphs_item import OrgDetailResponseGraphsItem
+  from ..models.org_detail_response_limits_type_0 import OrgDetailResponseLimitsType0
+  from ..models.org_detail_response_members_item import OrgDetailResponseMembersItem
+
+
+T = TypeVar("T", bound="OrgDetailResponse")
+
+
+@_attrs_define
+class OrgDetailResponse:
+  """Detailed organization response.
+
+  Attributes:
+      id (str):
+      name (str):
+      org_type (OrgType):
+      user_role (OrgRole):
+      members (list['OrgDetailResponseMembersItem']):
+      graphs (list['OrgDetailResponseGraphsItem']):
+      limits (Union['OrgDetailResponseLimitsType0', None]):
+      created_at (datetime.datetime):
+      updated_at (datetime.datetime):
+  """
+
+  id: str
+  name: str
+  org_type: OrgType
+  user_role: OrgRole
+  members: list["OrgDetailResponseMembersItem"]
+  graphs: list["OrgDetailResponseGraphsItem"]
+  limits: Union["OrgDetailResponseLimitsType0", None]
+  created_at: datetime.datetime
+  updated_at: datetime.datetime
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.org_detail_response_limits_type_0 import OrgDetailResponseLimitsType0
+
+    id = self.id
+
+    name = self.name
+
+    org_type = self.org_type.value
+
+    user_role = self.user_role.value
+
+    members = []
+    for members_item_data in self.members:
+      members_item = members_item_data.to_dict()
+      members.append(members_item)
+
+    graphs = []
+    for graphs_item_data in self.graphs:
+      graphs_item = graphs_item_data.to_dict()
+      graphs.append(graphs_item)
+
+    limits: Union[None, dict[str, Any]]
+    if isinstance(self.limits, OrgDetailResponseLimitsType0):
+      limits = self.limits.to_dict()
+    else:
+      limits = self.limits
+
+    created_at = self.created_at.isoformat()
+
+    updated_at = self.updated_at.isoformat()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "name": name,
+        "org_type": org_type,
+        "user_role": user_role,
+        "members": members,
+        "graphs": graphs,
+        "limits": limits,
+        "created_at": created_at,
+        "updated_at": updated_at,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.org_detail_response_graphs_item import OrgDetailResponseGraphsItem
+    from ..models.org_detail_response_limits_type_0 import OrgDetailResponseLimitsType0
+    from ..models.org_detail_response_members_item import OrgDetailResponseMembersItem
+
+    d = dict(src_dict)
+    id = d.pop("id")
+
+    name = d.pop("name")
+
+    org_type = OrgType(d.pop("org_type"))
+
+    user_role = OrgRole(d.pop("user_role"))
+
+    members = []
+    _members = d.pop("members")
+    for members_item_data in _members:
+      members_item = OrgDetailResponseMembersItem.from_dict(members_item_data)
+
+      members.append(members_item)
+
+    graphs = []
+    _graphs = d.pop("graphs")
+    for graphs_item_data in _graphs:
+      graphs_item = OrgDetailResponseGraphsItem.from_dict(graphs_item_data)
+
+      graphs.append(graphs_item)
+
+    def _parse_limits(data: object) -> Union["OrgDetailResponseLimitsType0", None]:
+      if data is None:
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        limits_type_0 = OrgDetailResponseLimitsType0.from_dict(data)
+
+        return limits_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["OrgDetailResponseLimitsType0", None], data)
+
+    limits = _parse_limits(d.pop("limits"))
+
+    created_at = isoparse(d.pop("created_at"))
+
+    updated_at = isoparse(d.pop("updated_at"))
+
+    org_detail_response = cls(
+      id=id,
+      name=name,
+      org_type=org_type,
+      user_role=user_role,
+      members=members,
+      graphs=graphs,
+      limits=limits,
+      created_at=created_at,
+      updated_at=updated_at,
+    )
+
+    org_detail_response.additional_properties = d
+    return org_detail_response
+
+  @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

robosystems_client/models/org_detail_response_graphs_item.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgDetailResponseGraphsItem")
+
+
+@_attrs_define
+class OrgDetailResponseGraphsItem:
+  """ """
+
+  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: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    org_detail_response_graphs_item = cls()
+
+    org_detail_response_graphs_item.additional_properties = d
+    return org_detail_response_graphs_item
+
+  @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

robosystems_client/models/org_detail_response_limits_type_0.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgDetailResponseLimitsType0")
+
+
+@_attrs_define
+class OrgDetailResponseLimitsType0:
+  """ """
+
+  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: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    org_detail_response_limits_type_0 = cls()
+
+    org_detail_response_limits_type_0.additional_properties = d
+    return org_detail_response_limits_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

robosystems_client/models/org_detail_response_members_item.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgDetailResponseMembersItem")
+
+
+@_attrs_define
+class OrgDetailResponseMembersItem:
+  """ """
+
+  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: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    org_detail_response_members_item = cls()
+
+    org_detail_response_members_item.additional_properties = d
+    return org_detail_response_members_item
+
+  @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

robosystems_client/models/org_limits_response.py

@@ -0,0 +1,98 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.org_limits_response_current_usage import OrgLimitsResponseCurrentUsage
+
+
+T = TypeVar("T", bound="OrgLimitsResponse")
+
+
+@_attrs_define
+class OrgLimitsResponse:
+  """Organization limits response.
+
+  Attributes:
+      org_id (str):
+      max_graphs (int):
+      current_usage (OrgLimitsResponseCurrentUsage):
+      warnings (list[str]):
+      can_create_graph (bool):
+  """
+
+  org_id: str
+  max_graphs: int
+  current_usage: "OrgLimitsResponseCurrentUsage"
+  warnings: list[str]
+  can_create_graph: bool
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    org_id = self.org_id
+
+    max_graphs = self.max_graphs
+
+    current_usage = self.current_usage.to_dict()
+
+    warnings = self.warnings
+
+    can_create_graph = self.can_create_graph
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "org_id": org_id,
+        "max_graphs": max_graphs,
+        "current_usage": current_usage,
+        "warnings": warnings,
+        "can_create_graph": can_create_graph,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.org_limits_response_current_usage import OrgLimitsResponseCurrentUsage
+
+    d = dict(src_dict)
+    org_id = d.pop("org_id")
+
+    max_graphs = d.pop("max_graphs")
+
+    current_usage = OrgLimitsResponseCurrentUsage.from_dict(d.pop("current_usage"))
+
+    warnings = cast(list[str], d.pop("warnings"))
+
+    can_create_graph = d.pop("can_create_graph")
+
+    org_limits_response = cls(
+      org_id=org_id,
+      max_graphs=max_graphs,
+      current_usage=current_usage,
+      warnings=warnings,
+      can_create_graph=can_create_graph,
+    )
+
+    org_limits_response.additional_properties = d
+    return org_limits_response
+
+  @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

robosystems_client/models/org_limits_response_current_usage.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OrgLimitsResponseCurrentUsage")
+
+
+@_attrs_define
+class OrgLimitsResponseCurrentUsage:
+  """ """
+
+  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: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    org_limits_response_current_usage = cls()
+
+    org_limits_response_current_usage.additional_properties = d
+    return org_limits_response_current_usage
+
+  @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

robosystems_client/models/org_list_response.py

@@ -0,0 +1,82 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.org_response import OrgResponse
+
+
+T = TypeVar("T", bound="OrgListResponse")
+
+
+@_attrs_define
+class OrgListResponse:
+  """List of organizations response.
+
+  Attributes:
+      orgs (list['OrgResponse']):
+      total (int):
+  """
+
+  orgs: list["OrgResponse"]
+  total: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    orgs = []
+    for orgs_item_data in self.orgs:
+      orgs_item = orgs_item_data.to_dict()
+      orgs.append(orgs_item)
+
+    total = self.total
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "orgs": orgs,
+        "total": total,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.org_response import OrgResponse
+
+    d = dict(src_dict)
+    orgs = []
+    _orgs = d.pop("orgs")
+    for orgs_item_data in _orgs:
+      orgs_item = OrgResponse.from_dict(orgs_item_data)
+
+      orgs.append(orgs_item)
+
+    total = d.pop("total")
+
+    org_list_response = cls(
+      orgs=orgs,
+      total=total,
+    )
+
+    org_list_response.additional_properties = d
+    return org_list_response
+
+  @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