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

robosystems_client/models/create_subgraph_request.py

@@ -0,0 +1,185 @@
+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 ..models.subgraph_type import SubgraphType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.create_subgraph_request_metadata_type_0 import (
+    CreateSubgraphRequestMetadataType0,
+  )
+
+
+T = TypeVar("T", bound="CreateSubgraphRequest")
+
+
+@_attrs_define
+class CreateSubgraphRequest:
+  """Request model for creating a subgraph.
+
+  Attributes:
+      name (str): Alphanumeric name for the subgraph (e.g., dev, staging, prod1)
+      display_name (str): Human-readable display name for the subgraph
+      description (Union[None, Unset, str]): Optional description of the subgraph's purpose
+      schema_extensions (Union[None, Unset, list[str]]): Schema extensions to include (inherits from parent by
+          default)
+      subgraph_type (Union[Unset, SubgraphType]): Types of subgraphs.
+      metadata (Union['CreateSubgraphRequestMetadataType0', None, Unset]): Additional metadata for the subgraph
+  """
+
+  name: str
+  display_name: str
+  description: Union[None, Unset, str] = UNSET
+  schema_extensions: Union[None, Unset, list[str]] = UNSET
+  subgraph_type: Union[Unset, SubgraphType] = UNSET
+  metadata: Union["CreateSubgraphRequestMetadataType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.create_subgraph_request_metadata_type_0 import (
+      CreateSubgraphRequestMetadataType0,
+    )
+
+    name = self.name
+
+    display_name = self.display_name
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    schema_extensions: Union[None, Unset, list[str]]
+    if isinstance(self.schema_extensions, Unset):
+      schema_extensions = UNSET
+    elif isinstance(self.schema_extensions, list):
+      schema_extensions = self.schema_extensions
+
+    else:
+      schema_extensions = self.schema_extensions
+
+    subgraph_type: Union[Unset, str] = UNSET
+    if not isinstance(self.subgraph_type, Unset):
+      subgraph_type = self.subgraph_type.value
+
+    metadata: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.metadata, Unset):
+      metadata = UNSET
+    elif isinstance(self.metadata, CreateSubgraphRequestMetadataType0):
+      metadata = self.metadata.to_dict()
+    else:
+      metadata = self.metadata
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+        "display_name": display_name,
+      }
+    )
+    if description is not UNSET:
+      field_dict["description"] = description
+    if schema_extensions is not UNSET:
+      field_dict["schema_extensions"] = schema_extensions
+    if subgraph_type is not UNSET:
+      field_dict["subgraph_type"] = subgraph_type
+    if metadata is not UNSET:
+      field_dict["metadata"] = metadata
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.create_subgraph_request_metadata_type_0 import (
+      CreateSubgraphRequestMetadataType0,
+    )
+
+    d = dict(src_dict)
+    name = d.pop("name")
+
+    display_name = d.pop("display_name")
+
+    def _parse_description(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)
+
+    description = _parse_description(d.pop("description", UNSET))
+
+    def _parse_schema_extensions(data: object) -> Union[None, Unset, list[str]]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        schema_extensions_type_0 = cast(list[str], data)
+
+        return schema_extensions_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[str]], data)
+
+    schema_extensions = _parse_schema_extensions(d.pop("schema_extensions", UNSET))
+
+    _subgraph_type = d.pop("subgraph_type", UNSET)
+    subgraph_type: Union[Unset, SubgraphType]
+    if isinstance(_subgraph_type, Unset):
+      subgraph_type = UNSET
+    else:
+      subgraph_type = SubgraphType(_subgraph_type)
+
+    def _parse_metadata(
+      data: object,
+    ) -> Union["CreateSubgraphRequestMetadataType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        metadata_type_0 = CreateSubgraphRequestMetadataType0.from_dict(data)
+
+        return metadata_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["CreateSubgraphRequestMetadataType0", None, Unset], data)
+
+    metadata = _parse_metadata(d.pop("metadata", UNSET))
+
+    create_subgraph_request = cls(
+      name=name,
+      display_name=display_name,
+      description=description,
+      schema_extensions=schema_extensions,
+      subgraph_type=subgraph_type,
+      metadata=metadata,
+    )
+
+    create_subgraph_request.additional_properties = d
+    return create_subgraph_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/create_subgraph_request_metadata_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="CreateSubgraphRequestMetadataType0")
+
+
+@_attrs_define
+class CreateSubgraphRequestMetadataType0:
+  """ """
+
+  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)
+    create_subgraph_request_metadata_type_0 = cls()
+
+    create_subgraph_request_metadata_type_0.additional_properties = d
+    return create_subgraph_request_metadata_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/credit_summary_response.py

@@ -16,7 +16,6 @@ class CreditSummaryResponse:
   Attributes:
       graph_id (str):
       graph_tier (str):
-      credit_multiplier (float):
       current_balance (float):
       monthly_allocation (float):
       consumed_this_month (float):
@@ -27,7 +26,6 @@ class CreditSummaryResponse:
 
   graph_id: str
   graph_tier: str
-  credit_multiplier: float
   current_balance: float
   monthly_allocation: float
   consumed_this_month: float
@@ -41,8 +39,6 @@ class CreditSummaryResponse:
 
     graph_tier = self.graph_tier
 
-    credit_multiplier = self.credit_multiplier
-
     current_balance = self.current_balance
 
     monthly_allocation = self.monthly_allocation
@@ -65,7 +61,6 @@ class CreditSummaryResponse:
       {
         "graph_id": graph_id,
         "graph_tier": graph_tier,
-        "credit_multiplier": credit_multiplier,
         "current_balance": current_balance,
         "monthly_allocation": monthly_allocation,
         "consumed_this_month": consumed_this_month,
@@ -85,8 +80,6 @@ class CreditSummaryResponse:
 
     graph_tier = d.pop("graph_tier")
 
-    credit_multiplier = d.pop("credit_multiplier")
-
     current_balance = d.pop("current_balance")
 
     monthly_allocation = d.pop("monthly_allocation")
@@ -111,7 +104,6 @@ class CreditSummaryResponse:
     credit_summary_response = cls(
       graph_id=graph_id,
       graph_tier=graph_tier,
-      credit_multiplier=credit_multiplier,
       current_balance=current_balance,
       monthly_allocation=monthly_allocation,
       consumed_this_month=consumed_this_month,

robosystems_client/models/delete_subgraph_request.py

@@ -0,0 +1,89 @@
+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="DeleteSubgraphRequest")
+
+
+@_attrs_define
+class DeleteSubgraphRequest:
+  """Request model for deleting a subgraph.
+
+  Attributes:
+      force (Union[Unset, bool]): Force deletion even if subgraph contains data Default: False.
+      backup_first (Union[Unset, bool]): Create a backup before deletion Default: True.
+      backup_location (Union[None, Unset, str]): S3 location for backup (uses default if not specified)
+  """
+
+  force: Union[Unset, bool] = False
+  backup_first: Union[Unset, bool] = True
+  backup_location: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    force = self.force
+
+    backup_first = self.backup_first
+
+    backup_location: Union[None, Unset, str]
+    if isinstance(self.backup_location, Unset):
+      backup_location = UNSET
+    else:
+      backup_location = self.backup_location
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update({})
+    if force is not UNSET:
+      field_dict["force"] = force
+    if backup_first is not UNSET:
+      field_dict["backup_first"] = backup_first
+    if backup_location is not UNSET:
+      field_dict["backup_location"] = backup_location
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    force = d.pop("force", UNSET)
+
+    backup_first = d.pop("backup_first", UNSET)
+
+    def _parse_backup_location(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)
+
+    backup_location = _parse_backup_location(d.pop("backup_location", UNSET))
+
+    delete_subgraph_request = cls(
+      force=force,
+      backup_first=backup_first,
+      backup_location=backup_location,
+    )
+
+    delete_subgraph_request.additional_properties = d
+    return delete_subgraph_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/delete_subgraph_response.py

@@ -0,0 +1,120 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DeleteSubgraphResponse")
+
+
+@_attrs_define
+class DeleteSubgraphResponse:
+  """Response model for subgraph deletion.
+
+  Attributes:
+      graph_id (str): Deleted subgraph identifier
+      status (str): Deletion status
+      deleted_at (datetime.datetime): When deletion occurred
+      backup_location (Union[None, Unset, str]): Location of backup if created
+      message (Union[None, Unset, str]): Additional information about the deletion
+  """
+
+  graph_id: str
+  status: str
+  deleted_at: datetime.datetime
+  backup_location: Union[None, Unset, str] = UNSET
+  message: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    status = self.status
+
+    deleted_at = self.deleted_at.isoformat()
+
+    backup_location: Union[None, Unset, str]
+    if isinstance(self.backup_location, Unset):
+      backup_location = UNSET
+    else:
+      backup_location = self.backup_location
+
+    message: Union[None, Unset, str]
+    if isinstance(self.message, Unset):
+      message = UNSET
+    else:
+      message = self.message
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "status": status,
+        "deleted_at": deleted_at,
+      }
+    )
+    if backup_location is not UNSET:
+      field_dict["backup_location"] = backup_location
+    if message is not UNSET:
+      field_dict["message"] = message
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    status = d.pop("status")
+
+    deleted_at = isoparse(d.pop("deleted_at"))
+
+    def _parse_backup_location(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)
+
+    backup_location = _parse_backup_location(d.pop("backup_location", UNSET))
+
+    def _parse_message(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)
+
+    message = _parse_message(d.pop("message", UNSET))
+
+    delete_subgraph_response = cls(
+      graph_id=graph_id,
+      status=status,
+      deleted_at=deleted_at,
+      backup_location=backup_location,
+      message=message,
+    )
+
+    delete_subgraph_response.additional_properties = d
+    return delete_subgraph_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/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