robosystems-client 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

robosystems_client/models/backup_limits.py

@@ -0,0 +1,76 @@
+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="BackupLimits")
+
+
+@_attrs_define
+class BackupLimits:
+  """Backup operation limits.
+
+  Attributes:
+      max_backup_size_gb (float): Maximum backup size in GB
+      backup_retention_days (int): Backup retention period in days
+      max_backups_per_day (int): Maximum backups per day
+  """
+
+  max_backup_size_gb: float
+  backup_retention_days: int
+  max_backups_per_day: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_backup_size_gb = self.max_backup_size_gb
+
+    backup_retention_days = self.backup_retention_days
+
+    max_backups_per_day = self.max_backups_per_day
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_backup_size_gb": max_backup_size_gb,
+        "backup_retention_days": backup_retention_days,
+        "max_backups_per_day": max_backups_per_day,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_backup_size_gb = d.pop("max_backup_size_gb")
+
+    backup_retention_days = d.pop("backup_retention_days")
+
+    max_backups_per_day = d.pop("max_backups_per_day")
+
+    backup_limits = cls(
+      max_backup_size_gb=max_backup_size_gb,
+      backup_retention_days=backup_retention_days,
+      max_backups_per_day=max_backups_per_day,
+    )
+
+    backup_limits.additional_properties = d
+    return backup_limits
+
+  @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/batch_agent_request.py

@@ -18,7 +18,7 @@ class BatchAgentRequest:
   """Request for batch processing multiple queries.
 
   Attributes:
-      queries (list['AgentRequest']): List of queries to process
+      queries (list['AgentRequest']): List of queries to process (max 10)
       parallel (Union[Unset, bool]): Process queries in parallel Default: False.
   """
 

robosystems_client/models/batch_agent_response.py

@@ -16,8 +16,8 @@ class BatchAgentResponse:
   """Response for batch processing.
 
   Attributes:
-      results (list['AgentResponse']): List of agent responses
-      total_execution_time (float): Total execution time
+      results (list['AgentResponse']): List of agent responses (includes successes and failures)
+      total_execution_time (float): Total execution time in seconds
       parallel_processed (bool): Whether queries were processed in parallel
   """
 

robosystems_client/models/copy_operation_limits.py

@@ -0,0 +1,100 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CopyOperationLimits")
+
+
+@_attrs_define
+class CopyOperationLimits:
+  """Copy/ingestion operation limits.
+
+  Attributes:
+      max_file_size_gb (float): Maximum file size in GB
+      timeout_seconds (int): Operation timeout in seconds
+      concurrent_operations (int): Maximum concurrent operations
+      max_files_per_operation (int): Maximum files per operation
+      daily_copy_operations (int): Daily operation limit
+      supported_formats (list[str]): Supported file formats
+  """
+
+  max_file_size_gb: float
+  timeout_seconds: int
+  concurrent_operations: int
+  max_files_per_operation: int
+  daily_copy_operations: int
+  supported_formats: list[str]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_file_size_gb = self.max_file_size_gb
+
+    timeout_seconds = self.timeout_seconds
+
+    concurrent_operations = self.concurrent_operations
+
+    max_files_per_operation = self.max_files_per_operation
+
+    daily_copy_operations = self.daily_copy_operations
+
+    supported_formats = self.supported_formats
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_file_size_gb": max_file_size_gb,
+        "timeout_seconds": timeout_seconds,
+        "concurrent_operations": concurrent_operations,
+        "max_files_per_operation": max_files_per_operation,
+        "daily_copy_operations": daily_copy_operations,
+        "supported_formats": supported_formats,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_file_size_gb = d.pop("max_file_size_gb")
+
+    timeout_seconds = d.pop("timeout_seconds")
+
+    concurrent_operations = d.pop("concurrent_operations")
+
+    max_files_per_operation = d.pop("max_files_per_operation")
+
+    daily_copy_operations = d.pop("daily_copy_operations")
+
+    supported_formats = cast(list[str], d.pop("supported_formats"))
+
+    copy_operation_limits = cls(
+      max_file_size_gb=max_file_size_gb,
+      timeout_seconds=timeout_seconds,
+      concurrent_operations=concurrent_operations,
+      max_files_per_operation=max_files_per_operation,
+      daily_copy_operations=daily_copy_operations,
+      supported_formats=supported_formats,
+    )
+
+    copy_operation_limits.additional_properties = d
+    return copy_operation_limits
+
+  @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_graph_request.py

@@ -19,23 +19,22 @@ T = TypeVar("T", bound="CreateGraphRequest")
 class CreateGraphRequest:
   """Request model for creating a new graph.
 
-  Example:
-      {'initial_entity': {'cik': '0001234567', 'name': 'Acme Consulting LLC', 'uri': 'https://acmeconsulting.com'},
-          'instance_tier': 'kuzu-standard', 'metadata': {'description': 'Professional consulting services with full
-          accounting integration', 'graph_name': 'Acme Consulting LLC', 'schema_extensions': ['roboledger']}, 'tags':
-          ['consulting', 'professional-services']}
-
-  Attributes:
-      metadata (GraphMetadata): Metadata for graph creation.
-      instance_tier (Union[Unset, str]): Instance tier: kuzu-standard, kuzu-large, kuzu-xlarge, neo4j-community-large,
-          neo4j-enterprise-xlarge Default: 'kuzu-standard'.
-      custom_schema (Union['CustomSchemaDefinition', None, Unset]): Custom schema definition to apply
-      initial_entity (Union['InitialEntityData', None, Unset]): Optional initial entity to create in the graph. If
-          provided, creates a entity-focused graph.
-      create_entity (Union[Unset, bool]): Whether to create the entity node and upload initial data. Only applies when
-          initial_entity is provided. Set to False to create graph without populating entity data (useful for file-based
-          ingestion workflows). Default: True.
-      tags (Union[Unset, list[str]]): Optional tags for organization
+  Use this to create either:
+  - **Entity graphs**: Standard graphs with entity schema and optional extensions
+  - **Custom graphs**: Generic graphs with fully custom schema definitions
+
+      Attributes:
+          metadata (GraphMetadata): Metadata for graph creation.
+          instance_tier (Union[Unset, str]): Instance tier: kuzu-standard, kuzu-large, kuzu-xlarge, neo4j-community-large,
+              neo4j-enterprise-xlarge Default: 'kuzu-standard'.
+          custom_schema (Union['CustomSchemaDefinition', None, Unset]): Custom schema definition to apply. If provided,
+              creates a generic custom graph. If omitted, creates an entity graph using schema_extensions.
+          initial_entity (Union['InitialEntityData', None, Unset]): Optional initial entity to create in the graph. If
+              provided with entity graph, populates the first entity node.
+          create_entity (Union[Unset, bool]): Whether to create the entity node and upload initial data. Only applies when
+              initial_entity is provided. Set to False to create graph without populating entity data (useful for file-based
+              ingestion workflows). Default: True.
+          tags (Union[Unset, list[str]]): Optional tags for organization
   """
 
   metadata: "GraphMetadata"

robosystems_client/models/credit_limits.py

@@ -0,0 +1,84 @@
+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="CreditLimits")
+
+
+@_attrs_define
+class CreditLimits:
+  """AI credit limits (optional).
+
+  Attributes:
+      monthly_ai_credits (int): Monthly AI credits allocation
+      current_balance (int): Current credit balance
+      storage_billing_enabled (bool): Whether storage billing is enabled
+      storage_rate_per_gb_per_day (int): Storage billing rate per GB per day
+  """
+
+  monthly_ai_credits: int
+  current_balance: int
+  storage_billing_enabled: bool
+  storage_rate_per_gb_per_day: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    monthly_ai_credits = self.monthly_ai_credits
+
+    current_balance = self.current_balance
+
+    storage_billing_enabled = self.storage_billing_enabled
+
+    storage_rate_per_gb_per_day = self.storage_rate_per_gb_per_day
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "monthly_ai_credits": monthly_ai_credits,
+        "current_balance": current_balance,
+        "storage_billing_enabled": storage_billing_enabled,
+        "storage_rate_per_gb_per_day": storage_rate_per_gb_per_day,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    monthly_ai_credits = d.pop("monthly_ai_credits")
+
+    current_balance = d.pop("current_balance")
+
+    storage_billing_enabled = d.pop("storage_billing_enabled")
+
+    storage_rate_per_gb_per_day = d.pop("storage_rate_per_gb_per_day")
+
+    credit_limits = cls(
+      monthly_ai_credits=monthly_ai_credits,
+      current_balance=current_balance,
+      storage_billing_enabled=storage_billing_enabled,
+      storage_rate_per_gb_per_day=storage_rate_per_gb_per_day,
+    )
+
+    credit_limits.additional_properties = d
+    return credit_limits
+
+  @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.py

@@ -21,16 +21,20 @@ T = TypeVar("T", bound="CustomSchemaDefinition")
 
 @_attrs_define
 class CustomSchemaDefinition:
-  """Custom schema definition for custom graphs.
-
-  Attributes:
-      name (str): Schema name
-      version (Union[Unset, str]): Schema version Default: '1.0.0'.
-      description (Union[None, Unset, str]): Schema description
-      extends (Union[None, Unset, str]): Base schema to extend (e.g., 'base')
-      nodes (Union[Unset, list['CustomSchemaDefinitionNodesItem']]): List of node definitions with properties
-      relationships (Union[Unset, list['CustomSchemaDefinitionRelationshipsItem']]): List of relationship definitions
-      metadata (Union[Unset, CustomSchemaDefinitionMetadata]): Additional schema metadata
+  """Custom schema definition for generic graphs.
+
+  This model allows you to define custom node types, relationship types, and properties
+  for graphs that don't fit the standard entity-based schema. Perfect for domain-specific
+  applications like inventory systems, org charts, project management, etc.
+
+      Attributes:
+          name (str): Schema name
+          version (Union[Unset, str]): Schema version Default: '1.0.0'.
+          description (Union[None, Unset, str]): Schema description
+          extends (Union[None, Unset, str]): Base schema to extend (e.g., 'base' for common utilities)
+          nodes (Union[Unset, list['CustomSchemaDefinitionNodesItem']]): List of node definitions with properties
+          relationships (Union[Unset, list['CustomSchemaDefinitionRelationshipsItem']]): List of relationship definitions
+          metadata (Union[Unset, CustomSchemaDefinitionMetadata]): Additional schema metadata
   """
 
   name: str

robosystems_client/models/execute_cypher_query_response_200.py

@@ -0,0 +1,135 @@
+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.execute_cypher_query_response_200_data_item import (
+    ExecuteCypherQueryResponse200DataItem,
+  )
+
+
+T = TypeVar("T", bound="ExecuteCypherQueryResponse200")
+
+
+@_attrs_define
+class ExecuteCypherQueryResponse200:
+  """
+  Attributes:
+      success (Union[Unset, bool]):
+      data (Union[Unset, list['ExecuteCypherQueryResponse200DataItem']]):
+      columns (Union[Unset, list[str]]):
+      row_count (Union[Unset, int]):
+      execution_time_ms (Union[Unset, float]):
+      graph_id (Union[Unset, str]):
+      timestamp (Union[Unset, str]):
+  """
+
+  success: Union[Unset, bool] = UNSET
+  data: Union[Unset, list["ExecuteCypherQueryResponse200DataItem"]] = UNSET
+  columns: Union[Unset, list[str]] = UNSET
+  row_count: Union[Unset, int] = UNSET
+  execution_time_ms: Union[Unset, float] = UNSET
+  graph_id: Union[Unset, str] = UNSET
+  timestamp: Union[Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    success = self.success
+
+    data: Union[Unset, list[dict[str, Any]]] = UNSET
+    if not isinstance(self.data, Unset):
+      data = []
+      for data_item_data in self.data:
+        data_item = data_item_data.to_dict()
+        data.append(data_item)
+
+    columns: Union[Unset, list[str]] = UNSET
+    if not isinstance(self.columns, Unset):
+      columns = self.columns
+
+    row_count = self.row_count
+
+    execution_time_ms = self.execution_time_ms
+
+    graph_id = self.graph_id
+
+    timestamp = self.timestamp
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update({})
+    if success is not UNSET:
+      field_dict["success"] = success
+    if data is not UNSET:
+      field_dict["data"] = data
+    if columns is not UNSET:
+      field_dict["columns"] = columns
+    if row_count is not UNSET:
+      field_dict["row_count"] = row_count
+    if execution_time_ms is not UNSET:
+      field_dict["execution_time_ms"] = execution_time_ms
+    if graph_id is not UNSET:
+      field_dict["graph_id"] = graph_id
+    if timestamp is not UNSET:
+      field_dict["timestamp"] = timestamp
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.execute_cypher_query_response_200_data_item import (
+      ExecuteCypherQueryResponse200DataItem,
+    )
+
+    d = dict(src_dict)
+    success = d.pop("success", UNSET)
+
+    data = []
+    _data = d.pop("data", UNSET)
+    for data_item_data in _data or []:
+      data_item = ExecuteCypherQueryResponse200DataItem.from_dict(data_item_data)
+
+      data.append(data_item)
+
+    columns = cast(list[str], d.pop("columns", UNSET))
+
+    row_count = d.pop("row_count", UNSET)
+
+    execution_time_ms = d.pop("execution_time_ms", UNSET)
+
+    graph_id = d.pop("graph_id", UNSET)
+
+    timestamp = d.pop("timestamp", UNSET)
+
+    execute_cypher_query_response_200 = cls(
+      success=success,
+      data=data,
+      columns=columns,
+      row_count=row_count,
+      execution_time_ms=execution_time_ms,
+      graph_id=graph_id,
+      timestamp=timestamp,
+    )
+
+    execute_cypher_query_response_200.additional_properties = d
+    return execute_cypher_query_response_200
+
+  @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_graph_limits_response_getgraphlimits.py → execute_cypher_query_response_200_data_item.py}

@@ -4,11 +4,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GetGraphLimitsResponseGetgraphlimits")
+T = TypeVar("T", bound="ExecuteCypherQueryResponse200DataItem")
 
 
 @_attrs_define
-class GetGraphLimitsResponseGetgraphlimits:
+class ExecuteCypherQueryResponse200DataItem:
   """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +22,10 @@ class GetGraphLimitsResponseGetgraphlimits:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    get_graph_limits_response_getgraphlimits = cls()
+    execute_cypher_query_response_200_data_item = cls()
 
-    get_graph_limits_response_getgraphlimits.additional_properties = d
-    return get_graph_limits_response_getgraphlimits
+    execute_cypher_query_response_200_data_item.additional_properties = d
+    return execute_cypher_query_response_200_data_item
 
   @property
   def additional_keys(self) -> list[str]: