robosystems-client 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

robosystems_client/models/get_all_shared_repository_limits_response_getallsharedrepositorylimits.py

@@ -0,0 +1,46 @@
+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="GetAllSharedRepositoryLimitsResponseGetallsharedrepositorylimits"
+)
+
+
+@_attrs_define
+class GetAllSharedRepositoryLimitsResponseGetallsharedrepositorylimits:
+  """ """
+
+  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)
+    get_all_shared_repository_limits_response_getallsharedrepositorylimits = cls()
+
+    get_all_shared_repository_limits_response_getallsharedrepositorylimits.additional_properties = d
+    return get_all_shared_repository_limits_response_getallsharedrepositorylimits
+
+  @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/get_shared_repository_limits_response_getsharedrepositorylimits.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="GetSharedRepositoryLimitsResponseGetsharedrepositorylimits")
+
+
+@_attrs_define
+class GetSharedRepositoryLimitsResponseGetsharedrepositorylimits:
+  """ """
+
+  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)
+    get_shared_repository_limits_response_getsharedrepositorylimits = cls()
+
+    get_shared_repository_limits_response_getsharedrepositorylimits.additional_properties = d
+    return get_shared_repository_limits_response_getsharedrepositorylimits
+
+  @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_subgraphs_response.py

@@ -0,0 +1,148 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.subgraph_summary import SubgraphSummary
+
+
+T = TypeVar("T", bound="ListSubgraphsResponse")
+
+
+@_attrs_define
+class ListSubgraphsResponse:
+  """Response model for listing subgraphs.
+
+  Attributes:
+      parent_graph_id (str): Parent graph identifier
+      parent_graph_name (str): Parent graph name
+      parent_graph_tier (str): Parent graph tier
+      subgraph_count (int): Total number of subgraphs
+      subgraphs (list['SubgraphSummary']): List of subgraphs
+      max_subgraphs (Union[None, Unset, int]): Maximum allowed subgraphs for this tier (None = unlimited)
+      total_size_mb (Union[None, Unset, float]): Combined size of all subgraphs in megabytes
+  """
+
+  parent_graph_id: str
+  parent_graph_name: str
+  parent_graph_tier: str
+  subgraph_count: int
+  subgraphs: list["SubgraphSummary"]
+  max_subgraphs: Union[None, Unset, int] = UNSET
+  total_size_mb: Union[None, Unset, float] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    parent_graph_id = self.parent_graph_id
+
+    parent_graph_name = self.parent_graph_name
+
+    parent_graph_tier = self.parent_graph_tier
+
+    subgraph_count = self.subgraph_count
+
+    subgraphs = []
+    for subgraphs_item_data in self.subgraphs:
+      subgraphs_item = subgraphs_item_data.to_dict()
+      subgraphs.append(subgraphs_item)
+
+    max_subgraphs: Union[None, Unset, int]
+    if isinstance(self.max_subgraphs, Unset):
+      max_subgraphs = UNSET
+    else:
+      max_subgraphs = self.max_subgraphs
+
+    total_size_mb: Union[None, Unset, float]
+    if isinstance(self.total_size_mb, Unset):
+      total_size_mb = UNSET
+    else:
+      total_size_mb = self.total_size_mb
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "parent_graph_id": parent_graph_id,
+        "parent_graph_name": parent_graph_name,
+        "parent_graph_tier": parent_graph_tier,
+        "subgraph_count": subgraph_count,
+        "subgraphs": subgraphs,
+      }
+    )
+    if max_subgraphs is not UNSET:
+      field_dict["max_subgraphs"] = max_subgraphs
+    if total_size_mb is not UNSET:
+      field_dict["total_size_mb"] = total_size_mb
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.subgraph_summary import SubgraphSummary
+
+    d = dict(src_dict)
+    parent_graph_id = d.pop("parent_graph_id")
+
+    parent_graph_name = d.pop("parent_graph_name")
+
+    parent_graph_tier = d.pop("parent_graph_tier")
+
+    subgraph_count = d.pop("subgraph_count")
+
+    subgraphs = []
+    _subgraphs = d.pop("subgraphs")
+    for subgraphs_item_data in _subgraphs:
+      subgraphs_item = SubgraphSummary.from_dict(subgraphs_item_data)
+
+      subgraphs.append(subgraphs_item)
+
+    def _parse_max_subgraphs(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)
+
+    max_subgraphs = _parse_max_subgraphs(d.pop("max_subgraphs", UNSET))
+
+    def _parse_total_size_mb(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    total_size_mb = _parse_total_size_mb(d.pop("total_size_mb", UNSET))
+
+    list_subgraphs_response = cls(
+      parent_graph_id=parent_graph_id,
+      parent_graph_name=parent_graph_name,
+      parent_graph_tier=parent_graph_tier,
+      subgraph_count=subgraph_count,
+      subgraphs=subgraphs,
+      max_subgraphs=max_subgraphs,
+      total_size_mb=total_size_mb,
+    )
+
+    list_subgraphs_response.additional_properties = d
+    return list_subgraphs_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/repository_credits_response.py

@@ -18,20 +18,20 @@ class RepositoryCreditsResponse:
   """Response for repository-specific credits.
 
   Attributes:
-      repository_type (str): Repository type
+      repository (str): Repository identifier
       has_access (bool): Whether user has access
       message (Union[Unset, str]): Access message
       credits_ (Union[Unset, CreditSummary]): Credit balance summary.
   """
 
-  repository_type: str
+  repository: str
   has_access: bool
   message: Union[Unset, str] = UNSET
   credits_: Union[Unset, "CreditSummary"] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
-    repository_type = self.repository_type
+    repository = self.repository
 
     has_access = self.has_access
 
@@ -45,7 +45,7 @@ class RepositoryCreditsResponse:
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
-        "repository_type": repository_type,
+        "repository": repository,
         "has_access": has_access,
       }
     )
@@ -61,7 +61,7 @@ class RepositoryCreditsResponse:
     from ..models.credit_summary import CreditSummary
 
     d = dict(src_dict)
-    repository_type = d.pop("repository_type")
+    repository = d.pop("repository")
 
     has_access = d.pop("has_access")
 
@@ -75,7 +75,7 @@ class RepositoryCreditsResponse:
       credits_ = CreditSummary.from_dict(_credits_)
 
     repository_credits_response = cls(
-      repository_type=repository_type,
+      repository=repository,
       has_access=has_access,
       message=message,
       credits_=credits_,

robosystems_client/models/schema_export_response.py

@@ -23,9 +23,9 @@ class SchemaExportResponse:
   """Response model for schema export.
 
   Attributes:
-      graph_id (str): Graph ID Example: entity_12345.
+      graph_id (str): Graph ID Example: kg1a2b3c4d5.
       schema_definition (Union['SchemaExportResponseSchemaDefinitionType0', str]): Exported schema definition Example:
-          {'name': 'entity_12345_schema', 'nodes': [{'name': 'Entity', 'properties': []}], 'relationships': [], 'version':
+          {'name': 'kg1a2b3c4d5_schema', 'nodes': [{'name': 'Entity', 'properties': []}], 'relationships': [], 'version':
           '1.0.0'}.
       format_ (str): Export format used Example: json.
       exported_at (str): Export timestamp Example: 2024-01-15T10:30:00Z.

robosystems_client/models/subgraph_quota_response.py

@@ -0,0 +1,158 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SubgraphQuotaResponse")
+
+
+@_attrs_define
+class SubgraphQuotaResponse:
+  """Response model for subgraph quota information.
+
+  Attributes:
+      parent_graph_id (str): Parent graph identifier
+      tier (str): Graph tier
+      current_count (int): Current number of subgraphs
+      max_allowed (Union[None, Unset, int]): Maximum allowed subgraphs (None = unlimited)
+      remaining (Union[None, Unset, int]): Remaining subgraphs that can be created
+      total_size_mb (Union[None, Unset, float]): Total size of all subgraphs
+      max_size_mb (Union[None, Unset, float]): Maximum allowed total size
+  """
+
+  parent_graph_id: str
+  tier: str
+  current_count: int
+  max_allowed: Union[None, Unset, int] = UNSET
+  remaining: Union[None, Unset, int] = UNSET
+  total_size_mb: Union[None, Unset, float] = UNSET
+  max_size_mb: Union[None, Unset, float] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    parent_graph_id = self.parent_graph_id
+
+    tier = self.tier
+
+    current_count = self.current_count
+
+    max_allowed: Union[None, Unset, int]
+    if isinstance(self.max_allowed, Unset):
+      max_allowed = UNSET
+    else:
+      max_allowed = self.max_allowed
+
+    remaining: Union[None, Unset, int]
+    if isinstance(self.remaining, Unset):
+      remaining = UNSET
+    else:
+      remaining = self.remaining
+
+    total_size_mb: Union[None, Unset, float]
+    if isinstance(self.total_size_mb, Unset):
+      total_size_mb = UNSET
+    else:
+      total_size_mb = self.total_size_mb
+
+    max_size_mb: Union[None, Unset, float]
+    if isinstance(self.max_size_mb, Unset):
+      max_size_mb = UNSET
+    else:
+      max_size_mb = self.max_size_mb
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "parent_graph_id": parent_graph_id,
+        "tier": tier,
+        "current_count": current_count,
+      }
+    )
+    if max_allowed is not UNSET:
+      field_dict["max_allowed"] = max_allowed
+    if remaining is not UNSET:
+      field_dict["remaining"] = remaining
+    if total_size_mb is not UNSET:
+      field_dict["total_size_mb"] = total_size_mb
+    if max_size_mb is not UNSET:
+      field_dict["max_size_mb"] = max_size_mb
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    parent_graph_id = d.pop("parent_graph_id")
+
+    tier = d.pop("tier")
+
+    current_count = d.pop("current_count")
+
+    def _parse_max_allowed(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)
+
+    max_allowed = _parse_max_allowed(d.pop("max_allowed", UNSET))
+
+    def _parse_remaining(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)
+
+    remaining = _parse_remaining(d.pop("remaining", UNSET))
+
+    def _parse_total_size_mb(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    total_size_mb = _parse_total_size_mb(d.pop("total_size_mb", UNSET))
+
+    def _parse_max_size_mb(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    max_size_mb = _parse_max_size_mb(d.pop("max_size_mb", UNSET))
+
+    subgraph_quota_response = cls(
+      parent_graph_id=parent_graph_id,
+      tier=tier,
+      current_count=current_count,
+      max_allowed=max_allowed,
+      remaining=remaining,
+      total_size_mb=total_size_mb,
+      max_size_mb=max_size_mb,
+    )
+
+    subgraph_quota_response.additional_properties = d
+    return subgraph_quota_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