robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/custom_schema_definition.py

@@ -0,0 +1,194 @@
+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.custom_schema_definition_metadata import CustomSchemaDefinitionMetadata
+  from ..models.custom_schema_definition_nodes_item import (
+    CustomSchemaDefinitionNodesItem,
+  )
+  from ..models.custom_schema_definition_relationships_item import (
+    CustomSchemaDefinitionRelationshipsItem,
+  )
+
+
+T = TypeVar("T", bound="CustomSchemaDefinition")
+
+
+@_attrs_define
+class CustomSchemaDefinition:
+  """Custom schema definition for user-defined graphs.
+
+  Attributes:
+      name (str): Schema name Example: inventory_management.
+      version (Union[Unset, str]): Schema version Default: '1.0.0'. Example: 1.0.0.
+      description (Union[None, Unset, str]): Schema description Example: Inventory management system schema.
+      extends (Union[None, Unset, str]): Base schema to extend (e.g., 'base') Example: base.
+      nodes (Union[Unset, list['CustomSchemaDefinitionNodesItem']]): List of node definitions with properties Example:
+          [{'name': 'Product', 'properties': [{'name': 'sku', 'type': 'STRING', 'is_primary_key': True}, {'name': 'name',
+          'type': 'STRING', 'is_required': True}, {'name': 'price', 'type': 'DOUBLE'}, {'name': 'quantity', 'type':
+          'INT64'}]}, {'name': 'Warehouse', 'properties': [{'name': 'id', 'type': 'STRING', 'is_primary_key': True},
+          {'name': 'location', 'type': 'STRING'}]}].
+      relationships (Union[Unset, list['CustomSchemaDefinitionRelationshipsItem']]): List of relationship definitions
+          Example: [{'from_node': 'Product', 'name': 'STORED_IN', 'properties': [{'name': 'since', 'type': 'DATE'}],
+          'to_node': 'Warehouse'}].
+      metadata (Union[Unset, CustomSchemaDefinitionMetadata]): Additional schema metadata Example: {'created_by':
+          'inventory_team', 'industry': 'retail'}.
+  """
+
+  name: str
+  version: Union[Unset, str] = "1.0.0"
+  description: Union[None, Unset, str] = UNSET
+  extends: Union[None, Unset, str] = UNSET
+  nodes: Union[Unset, list["CustomSchemaDefinitionNodesItem"]] = UNSET
+  relationships: Union[Unset, list["CustomSchemaDefinitionRelationshipsItem"]] = UNSET
+  metadata: Union[Unset, "CustomSchemaDefinitionMetadata"] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    name = self.name
+
+    version = self.version
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    extends: Union[None, Unset, str]
+    if isinstance(self.extends, Unset):
+      extends = UNSET
+    else:
+      extends = self.extends
+
+    nodes: Union[Unset, list[dict[str, Any]]] = UNSET
+    if not isinstance(self.nodes, Unset):
+      nodes = []
+      for nodes_item_data in self.nodes:
+        nodes_item = nodes_item_data.to_dict()
+        nodes.append(nodes_item)
+
+    relationships: Union[Unset, list[dict[str, Any]]] = UNSET
+    if not isinstance(self.relationships, Unset):
+      relationships = []
+      for relationships_item_data in self.relationships:
+        relationships_item = relationships_item_data.to_dict()
+        relationships.append(relationships_item)
+
+    metadata: Union[Unset, dict[str, Any]] = UNSET
+    if not isinstance(self.metadata, Unset):
+      metadata = self.metadata.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+      }
+    )
+    if version is not UNSET:
+      field_dict["version"] = version
+    if description is not UNSET:
+      field_dict["description"] = description
+    if extends is not UNSET:
+      field_dict["extends"] = extends
+    if nodes is not UNSET:
+      field_dict["nodes"] = nodes
+    if relationships is not UNSET:
+      field_dict["relationships"] = relationships
+    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.custom_schema_definition_metadata import (
+      CustomSchemaDefinitionMetadata,
+    )
+    from ..models.custom_schema_definition_nodes_item import (
+      CustomSchemaDefinitionNodesItem,
+    )
+    from ..models.custom_schema_definition_relationships_item import (
+      CustomSchemaDefinitionRelationshipsItem,
+    )
+
+    d = dict(src_dict)
+    name = d.pop("name")
+
+    version = d.pop("version", UNSET)
+
+    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_extends(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)
+
+    extends = _parse_extends(d.pop("extends", UNSET))
+
+    nodes = []
+    _nodes = d.pop("nodes", UNSET)
+    for nodes_item_data in _nodes or []:
+      nodes_item = CustomSchemaDefinitionNodesItem.from_dict(nodes_item_data)
+
+      nodes.append(nodes_item)
+
+    relationships = []
+    _relationships = d.pop("relationships", UNSET)
+    for relationships_item_data in _relationships or []:
+      relationships_item = CustomSchemaDefinitionRelationshipsItem.from_dict(
+        relationships_item_data
+      )
+
+      relationships.append(relationships_item)
+
+    _metadata = d.pop("metadata", UNSET)
+    metadata: Union[Unset, CustomSchemaDefinitionMetadata]
+    if isinstance(_metadata, Unset):
+      metadata = UNSET
+    else:
+      metadata = CustomSchemaDefinitionMetadata.from_dict(_metadata)
+
+    custom_schema_definition = cls(
+      name=name,
+      version=version,
+      description=description,
+      extends=extends,
+      nodes=nodes,
+      relationships=relationships,
+      metadata=metadata,
+    )
+
+    custom_schema_definition.additional_properties = d
+    return custom_schema_definition
+
+  @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/custom_schema_definition_metadata.py

@@ -0,0 +1,49 @@
+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="CustomSchemaDefinitionMetadata")
+
+
+@_attrs_define
+class CustomSchemaDefinitionMetadata:
+  """Additional schema metadata
+
+  Example:
+      {'created_by': 'inventory_team', 'industry': 'retail'}
+
+  """
+
+  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)
+    custom_schema_definition_metadata = cls()
+
+    custom_schema_definition_metadata.additional_properties = d
+    return custom_schema_definition_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/custom_schema_definition_nodes_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="CustomSchemaDefinitionNodesItem")
+
+
+@_attrs_define
+class CustomSchemaDefinitionNodesItem:
+  """ """
+
+  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)
+    custom_schema_definition_nodes_item = cls()
+
+    custom_schema_definition_nodes_item.additional_properties = d
+    return custom_schema_definition_nodes_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/custom_schema_definition_relationships_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="CustomSchemaDefinitionRelationshipsItem")
+
+
+@_attrs_define
+class CustomSchemaDefinitionRelationshipsItem:
+  """ """
+
+  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)
+    custom_schema_definition_relationships_item = cls()
+
+    custom_schema_definition_relationships_item.additional_properties = d
+    return custom_schema_definition_relationships_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/cypher_query_request.py

@@ -0,0 +1,128 @@
+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.cypher_query_request_parameters_type_0 import (
+    CypherQueryRequestParametersType0,
+  )
+
+
+T = TypeVar("T", bound="CypherQueryRequest")
+
+
+@_attrs_define
+class CypherQueryRequest:
+  """Request model for Cypher query execution.
+
+  Attributes:
+      query (str): The Cypher query to execute
+      parameters (Union['CypherQueryRequestParametersType0', None, Unset]): Optional parameters for the Cypher query
+      timeout (Union[None, Unset, int]): Query timeout in seconds (1-300) Default: 60.
+  """
+
+  query: str
+  parameters: Union["CypherQueryRequestParametersType0", None, Unset] = UNSET
+  timeout: Union[None, Unset, int] = 60
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.cypher_query_request_parameters_type_0 import (
+      CypherQueryRequestParametersType0,
+    )
+
+    query = self.query
+
+    parameters: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.parameters, Unset):
+      parameters = UNSET
+    elif isinstance(self.parameters, CypherQueryRequestParametersType0):
+      parameters = self.parameters.to_dict()
+    else:
+      parameters = self.parameters
+
+    timeout: Union[None, Unset, int]
+    if isinstance(self.timeout, Unset):
+      timeout = UNSET
+    else:
+      timeout = self.timeout
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "query": query,
+      }
+    )
+    if parameters is not UNSET:
+      field_dict["parameters"] = parameters
+    if timeout is not UNSET:
+      field_dict["timeout"] = timeout
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.cypher_query_request_parameters_type_0 import (
+      CypherQueryRequestParametersType0,
+    )
+
+    d = dict(src_dict)
+    query = d.pop("query")
+
+    def _parse_parameters(
+      data: object,
+    ) -> Union["CypherQueryRequestParametersType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        parameters_type_0 = CypherQueryRequestParametersType0.from_dict(data)
+
+        return parameters_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["CypherQueryRequestParametersType0", None, Unset], data)
+
+    parameters = _parse_parameters(d.pop("parameters", UNSET))
+
+    def _parse_timeout(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)
+
+    timeout = _parse_timeout(d.pop("timeout", UNSET))
+
+    cypher_query_request = cls(
+      query=query,
+      parameters=parameters,
+      timeout=timeout,
+    )
+
+    cypher_query_request.additional_properties = d
+    return cypher_query_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/cypher_query_request_parameters_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="CypherQueryRequestParametersType0")
+
+
+@_attrs_define
+class CypherQueryRequestParametersType0:
+  """ """
+
+  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)
+    cypher_query_request_parameters_type_0 = cls()
+
+    cypher_query_request_parameters_type_0.additional_properties = d
+    return cypher_query_request_parameters_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/database_health_response.py

@@ -0,0 +1,181 @@
+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="DatabaseHealthResponse")
+
+
+@_attrs_define
+class DatabaseHealthResponse:
+  """Response model for database health check.
+
+  Attributes:
+      graph_id (str): Graph database identifier Example: entity_12345.
+      status (str): Overall health status Example: healthy.
+      connection_status (str): Database connection status Example: connected.
+      uptime_seconds (float): Database uptime in seconds Example: 3600.5.
+      query_count_24h (int): Number of queries executed in last 24 hours Example: 150.
+      avg_query_time_ms (float): Average query execution time in milliseconds Example: 45.2.
+      error_rate_24h (float): Error rate in last 24 hours (percentage) Example: 0.5.
+      last_query_time (Union[None, Unset, str]): Timestamp of last query execution Example: 2024-01-15T10:30:00Z.
+      memory_usage_mb (Union[None, Unset, float]): Memory usage in MB Example: 512.3.
+      storage_usage_mb (Union[None, Unset, float]): Storage usage in MB Example: 1024.7.
+      alerts (Union[Unset, list[str]]): Active alerts or warnings Example: ['High memory usage detected'].
+  """
+
+  graph_id: str
+  status: str
+  connection_status: str
+  uptime_seconds: float
+  query_count_24h: int
+  avg_query_time_ms: float
+  error_rate_24h: float
+  last_query_time: Union[None, Unset, str] = UNSET
+  memory_usage_mb: Union[None, Unset, float] = UNSET
+  storage_usage_mb: Union[None, Unset, float] = UNSET
+  alerts: Union[Unset, list[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
+
+    connection_status = self.connection_status
+
+    uptime_seconds = self.uptime_seconds
+
+    query_count_24h = self.query_count_24h
+
+    avg_query_time_ms = self.avg_query_time_ms
+
+    error_rate_24h = self.error_rate_24h
+
+    last_query_time: Union[None, Unset, str]
+    if isinstance(self.last_query_time, Unset):
+      last_query_time = UNSET
+    else:
+      last_query_time = self.last_query_time
+
+    memory_usage_mb: Union[None, Unset, float]
+    if isinstance(self.memory_usage_mb, Unset):
+      memory_usage_mb = UNSET
+    else:
+      memory_usage_mb = self.memory_usage_mb
+
+    storage_usage_mb: Union[None, Unset, float]
+    if isinstance(self.storage_usage_mb, Unset):
+      storage_usage_mb = UNSET
+    else:
+      storage_usage_mb = self.storage_usage_mb
+
+    alerts: Union[Unset, list[str]] = UNSET
+    if not isinstance(self.alerts, Unset):
+      alerts = self.alerts
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "status": status,
+        "connection_status": connection_status,
+        "uptime_seconds": uptime_seconds,
+        "query_count_24h": query_count_24h,
+        "avg_query_time_ms": avg_query_time_ms,
+        "error_rate_24h": error_rate_24h,
+      }
+    )
+    if last_query_time is not UNSET:
+      field_dict["last_query_time"] = last_query_time
+    if memory_usage_mb is not UNSET:
+      field_dict["memory_usage_mb"] = memory_usage_mb
+    if storage_usage_mb is not UNSET:
+      field_dict["storage_usage_mb"] = storage_usage_mb
+    if alerts is not UNSET:
+      field_dict["alerts"] = alerts
+
+    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")
+
+    connection_status = d.pop("connection_status")
+
+    uptime_seconds = d.pop("uptime_seconds")
+
+    query_count_24h = d.pop("query_count_24h")
+
+    avg_query_time_ms = d.pop("avg_query_time_ms")
+
+    error_rate_24h = d.pop("error_rate_24h")
+
+    def _parse_last_query_time(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)
+
+    last_query_time = _parse_last_query_time(d.pop("last_query_time", UNSET))
+
+    def _parse_memory_usage_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)
+
+    memory_usage_mb = _parse_memory_usage_mb(d.pop("memory_usage_mb", UNSET))
+
+    def _parse_storage_usage_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)
+
+    storage_usage_mb = _parse_storage_usage_mb(d.pop("storage_usage_mb", UNSET))
+
+    alerts = cast(list[str], d.pop("alerts", UNSET))
+
+    database_health_response = cls(
+      graph_id=graph_id,
+      status=status,
+      connection_status=connection_status,
+      uptime_seconds=uptime_seconds,
+      query_count_24h=query_count_24h,
+      avg_query_time_ms=avg_query_time_ms,
+      error_rate_24h=error_rate_24h,
+      last_query_time=last_query_time,
+      memory_usage_mb=memory_usage_mb,
+      storage_usage_mb=storage_usage_mb,
+      alerts=alerts,
+    )
+
+    database_health_response.additional_properties = d
+    return database_health_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