robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/get_mcp_health_response_getmcphealth.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="GetMCPHealthResponseGetmcphealth")
+
+
+@_attrs_define
+class GetMCPHealthResponseGetmcphealth:
+  """ """
+
+  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_mcp_health_response_getmcphealth = cls()
+
+    get_mcp_health_response_getmcphealth.additional_properties = d
+    return get_mcp_health_response_getmcphealth
+
+  @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_operation_status_response_getoperationstatus.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="GetOperationStatusResponseGetoperationstatus")
+
+
+@_attrs_define
+class GetOperationStatusResponseGetoperationstatus:
+  """ """
+
+  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_operation_status_response_getoperationstatus = cls()
+
+    get_operation_status_response_getoperationstatus.additional_properties = d
+    return get_operation_status_response_getoperationstatus
+
+  @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_storage_usage_response_getstorageusage.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="GetStorageUsageResponseGetstorageusage")
+
+
+@_attrs_define
+class GetStorageUsageResponseGetstorageusage:
+  """ """
+
+  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_storage_usage_response_getstorageusage = cls()
+
+    get_storage_usage_response_getstorageusage.additional_properties = d
+    return get_storage_usage_response_getstorageusage
+
+  @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/graph_info.py

@@ -0,0 +1,92 @@
+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="GraphInfo")
+
+
+@_attrs_define
+class GraphInfo:
+  """Graph information for user.
+
+  Attributes:
+      graph_id (str): Graph database identifier
+      graph_name (str): Display name for the graph
+      role (str): User's role in this graph
+      is_selected (bool): Whether this is the currently selected graph
+      created_at (str): Creation timestamp
+  """
+
+  graph_id: str
+  graph_name: str
+  role: str
+  is_selected: bool
+  created_at: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    graph_name = self.graph_name
+
+    role = self.role
+
+    is_selected = self.is_selected
+
+    created_at = self.created_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graphId": graph_id,
+        "graphName": graph_name,
+        "role": role,
+        "isSelected": is_selected,
+        "createdAt": created_at,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    graph_id = d.pop("graphId")
+
+    graph_name = d.pop("graphName")
+
+    role = d.pop("role")
+
+    is_selected = d.pop("isSelected")
+
+    created_at = d.pop("createdAt")
+
+    graph_info = cls(
+      graph_id=graph_id,
+      graph_name=graph_name,
+      role=role,
+      is_selected=is_selected,
+      created_at=created_at,
+    )
+
+    graph_info.additional_properties = d
+    return graph_info
+
+  @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/graph_metadata.py

@@ -0,0 +1,105 @@
+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="GraphMetadata")
+
+
+@_attrs_define
+class GraphMetadata:
+  """Metadata for graph creation.
+
+  Attributes:
+      graph_name (str): Display name for the graph Example: Production Inventory.
+      description (Union[None, Unset, str]): Optional description Example: Main inventory tracking system for
+          production environment.
+      schema_extensions (Union[Unset, list[str]]): Schema extensions to enable Example: ['roboledger'].
+      tags (Union[Unset, list[str]]): Tags for organizing graphs Example: ['production', 'inventory', 'retail'].
+  """
+
+  graph_name: str
+  description: Union[None, Unset, str] = UNSET
+  schema_extensions: Union[Unset, list[str]] = UNSET
+  tags: Union[Unset, list[str]] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_name = self.graph_name
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    schema_extensions: Union[Unset, list[str]] = UNSET
+    if not isinstance(self.schema_extensions, Unset):
+      schema_extensions = self.schema_extensions
+
+    tags: Union[Unset, list[str]] = UNSET
+    if not isinstance(self.tags, Unset):
+      tags = self.tags
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_name": graph_name,
+      }
+    )
+    if description is not UNSET:
+      field_dict["description"] = description
+    if schema_extensions is not UNSET:
+      field_dict["schema_extensions"] = schema_extensions
+    if tags is not UNSET:
+      field_dict["tags"] = tags
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    graph_name = d.pop("graph_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))
+
+    schema_extensions = cast(list[str], d.pop("schema_extensions", UNSET))
+
+    tags = cast(list[str], d.pop("tags", UNSET))
+
+    graph_metadata = cls(
+      graph_name=graph_name,
+      description=description,
+      schema_extensions=schema_extensions,
+      tags=tags,
+    )
+
+    graph_metadata.additional_properties = d
+    return graph_metadata
+
+  @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/graph_metrics_response.py

@@ -0,0 +1,188 @@
+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.graph_metrics_response_estimated_size import (
+    GraphMetricsResponseEstimatedSize,
+  )
+  from ..models.graph_metrics_response_health_status import (
+    GraphMetricsResponseHealthStatus,
+  )
+  from ..models.graph_metrics_response_node_counts import GraphMetricsResponseNodeCounts
+  from ..models.graph_metrics_response_relationship_counts import (
+    GraphMetricsResponseRelationshipCounts,
+  )
+
+
+T = TypeVar("T", bound="GraphMetricsResponse")
+
+
+@_attrs_define
+class GraphMetricsResponse:
+  """Response model for graph metrics.
+
+  Attributes:
+      graph_id (str): Graph database identifier
+      timestamp (str): Metrics collection timestamp
+      total_nodes (int): Total number of nodes
+      total_relationships (int): Total number of relationships
+      node_counts (GraphMetricsResponseNodeCounts): Node counts by label
+      relationship_counts (GraphMetricsResponseRelationshipCounts): Relationship counts by type
+      estimated_size (GraphMetricsResponseEstimatedSize): Database size estimates
+      health_status (GraphMetricsResponseHealthStatus): Database health information
+      graph_name (Union[None, Unset, str]): Display name for the graph
+      user_role (Union[None, Unset, str]): User's role in this graph
+  """
+
+  graph_id: str
+  timestamp: str
+  total_nodes: int
+  total_relationships: int
+  node_counts: "GraphMetricsResponseNodeCounts"
+  relationship_counts: "GraphMetricsResponseRelationshipCounts"
+  estimated_size: "GraphMetricsResponseEstimatedSize"
+  health_status: "GraphMetricsResponseHealthStatus"
+  graph_name: Union[None, Unset, str] = UNSET
+  user_role: 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
+
+    timestamp = self.timestamp
+
+    total_nodes = self.total_nodes
+
+    total_relationships = self.total_relationships
+
+    node_counts = self.node_counts.to_dict()
+
+    relationship_counts = self.relationship_counts.to_dict()
+
+    estimated_size = self.estimated_size.to_dict()
+
+    health_status = self.health_status.to_dict()
+
+    graph_name: Union[None, Unset, str]
+    if isinstance(self.graph_name, Unset):
+      graph_name = UNSET
+    else:
+      graph_name = self.graph_name
+
+    user_role: Union[None, Unset, str]
+    if isinstance(self.user_role, Unset):
+      user_role = UNSET
+    else:
+      user_role = self.user_role
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "timestamp": timestamp,
+        "total_nodes": total_nodes,
+        "total_relationships": total_relationships,
+        "node_counts": node_counts,
+        "relationship_counts": relationship_counts,
+        "estimated_size": estimated_size,
+        "health_status": health_status,
+      }
+    )
+    if graph_name is not UNSET:
+      field_dict["graph_name"] = graph_name
+    if user_role is not UNSET:
+      field_dict["user_role"] = user_role
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.graph_metrics_response_estimated_size import (
+      GraphMetricsResponseEstimatedSize,
+    )
+    from ..models.graph_metrics_response_health_status import (
+      GraphMetricsResponseHealthStatus,
+    )
+    from ..models.graph_metrics_response_node_counts import (
+      GraphMetricsResponseNodeCounts,
+    )
+    from ..models.graph_metrics_response_relationship_counts import (
+      GraphMetricsResponseRelationshipCounts,
+    )
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    timestamp = d.pop("timestamp")
+
+    total_nodes = d.pop("total_nodes")
+
+    total_relationships = d.pop("total_relationships")
+
+    node_counts = GraphMetricsResponseNodeCounts.from_dict(d.pop("node_counts"))
+
+    relationship_counts = GraphMetricsResponseRelationshipCounts.from_dict(
+      d.pop("relationship_counts")
+    )
+
+    estimated_size = GraphMetricsResponseEstimatedSize.from_dict(
+      d.pop("estimated_size")
+    )
+
+    health_status = GraphMetricsResponseHealthStatus.from_dict(d.pop("health_status"))
+
+    def _parse_graph_name(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)
+
+    graph_name = _parse_graph_name(d.pop("graph_name", UNSET))
+
+    def _parse_user_role(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)
+
+    user_role = _parse_user_role(d.pop("user_role", UNSET))
+
+    graph_metrics_response = cls(
+      graph_id=graph_id,
+      timestamp=timestamp,
+      total_nodes=total_nodes,
+      total_relationships=total_relationships,
+      node_counts=node_counts,
+      relationship_counts=relationship_counts,
+      estimated_size=estimated_size,
+      health_status=health_status,
+      graph_name=graph_name,
+      user_role=user_role,
+    )
+
+    graph_metrics_response.additional_properties = d
+    return graph_metrics_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/graph_metrics_response_estimated_size.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="GraphMetricsResponseEstimatedSize")
+
+
+@_attrs_define
+class GraphMetricsResponseEstimatedSize:
+  """Database size estimates"""
+
+  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)
+    graph_metrics_response_estimated_size = cls()
+
+    graph_metrics_response_estimated_size.additional_properties = d
+    return graph_metrics_response_estimated_size
+
+  @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/graph_metrics_response_health_status.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="GraphMetricsResponseHealthStatus")
+
+
+@_attrs_define
+class GraphMetricsResponseHealthStatus:
+  """Database health information"""
+
+  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)
+    graph_metrics_response_health_status = cls()
+
+    graph_metrics_response_health_status.additional_properties = d
+    return graph_metrics_response_health_status
+
+  @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/graph_metrics_response_node_counts.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="GraphMetricsResponseNodeCounts")
+
+
+@_attrs_define
+class GraphMetricsResponseNodeCounts:
+  """Node counts by label"""
+
+  additional_properties: dict[str, int] = _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)
+    graph_metrics_response_node_counts = cls()
+
+    graph_metrics_response_node_counts.additional_properties = d
+    return graph_metrics_response_node_counts
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> int:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: int) -> 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/graph_metrics_response_relationship_counts.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="GraphMetricsResponseRelationshipCounts")
+
+
+@_attrs_define
+class GraphMetricsResponseRelationshipCounts:
+  """Relationship counts by type"""
+
+  additional_properties: dict[str, int] = _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)
+    graph_metrics_response_relationship_counts = cls()
+
+    graph_metrics_response_relationship_counts.additional_properties = d
+    return graph_metrics_response_relationship_counts
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> int:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: int) -> 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