robosystems-client 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

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]:

robosystems_client/models/graph_limits_response.py

@@ -0,0 +1,174 @@
+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.backup_limits import BackupLimits
+  from ..models.copy_operation_limits import CopyOperationLimits
+  from ..models.credit_limits import CreditLimits
+  from ..models.query_limits import QueryLimits
+  from ..models.rate_limits import RateLimits
+  from ..models.storage_limits import StorageLimits
+
+
+T = TypeVar("T", bound="GraphLimitsResponse")
+
+
+@_attrs_define
+class GraphLimitsResponse:
+  """Response model for comprehensive graph operational limits.
+
+  Attributes:
+      graph_id (str): Graph database identifier
+      subscription_tier (str): User's subscription tier
+      graph_tier (str): Graph's database tier
+      is_shared_repository (bool): Whether this is a shared repository
+      storage (StorageLimits): Storage limits information.
+      queries (QueryLimits): Query operation limits.
+      copy_operations (CopyOperationLimits): Copy/ingestion operation limits.
+      backups (BackupLimits): Backup operation limits.
+      rate_limits (RateLimits): API rate limits.
+      credits_ (Union['CreditLimits', None, Unset]): AI credit limits (if applicable)
+  """
+
+  graph_id: str
+  subscription_tier: str
+  graph_tier: str
+  is_shared_repository: bool
+  storage: "StorageLimits"
+  queries: "QueryLimits"
+  copy_operations: "CopyOperationLimits"
+  backups: "BackupLimits"
+  rate_limits: "RateLimits"
+  credits_: Union["CreditLimits", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.credit_limits import CreditLimits
+
+    graph_id = self.graph_id
+
+    subscription_tier = self.subscription_tier
+
+    graph_tier = self.graph_tier
+
+    is_shared_repository = self.is_shared_repository
+
+    storage = self.storage.to_dict()
+
+    queries = self.queries.to_dict()
+
+    copy_operations = self.copy_operations.to_dict()
+
+    backups = self.backups.to_dict()
+
+    rate_limits = self.rate_limits.to_dict()
+
+    credits_: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.credits_, Unset):
+      credits_ = UNSET
+    elif isinstance(self.credits_, CreditLimits):
+      credits_ = self.credits_.to_dict()
+    else:
+      credits_ = self.credits_
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "subscription_tier": subscription_tier,
+        "graph_tier": graph_tier,
+        "is_shared_repository": is_shared_repository,
+        "storage": storage,
+        "queries": queries,
+        "copy_operations": copy_operations,
+        "backups": backups,
+        "rate_limits": rate_limits,
+      }
+    )
+    if credits_ is not UNSET:
+      field_dict["credits"] = credits_
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.backup_limits import BackupLimits
+    from ..models.copy_operation_limits import CopyOperationLimits
+    from ..models.credit_limits import CreditLimits
+    from ..models.query_limits import QueryLimits
+    from ..models.rate_limits import RateLimits
+    from ..models.storage_limits import StorageLimits
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    subscription_tier = d.pop("subscription_tier")
+
+    graph_tier = d.pop("graph_tier")
+
+    is_shared_repository = d.pop("is_shared_repository")
+
+    storage = StorageLimits.from_dict(d.pop("storage"))
+
+    queries = QueryLimits.from_dict(d.pop("queries"))
+
+    copy_operations = CopyOperationLimits.from_dict(d.pop("copy_operations"))
+
+    backups = BackupLimits.from_dict(d.pop("backups"))
+
+    rate_limits = RateLimits.from_dict(d.pop("rate_limits"))
+
+    def _parse_credits_(data: object) -> Union["CreditLimits", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        credits_type_0 = CreditLimits.from_dict(data)
+
+        return credits_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["CreditLimits", None, Unset], data)
+
+    credits_ = _parse_credits_(d.pop("credits", UNSET))
+
+    graph_limits_response = cls(
+      graph_id=graph_id,
+      subscription_tier=subscription_tier,
+      graph_tier=graph_tier,
+      is_shared_repository=is_shared_repository,
+      storage=storage,
+      queries=queries,
+      copy_operations=copy_operations,
+      backups=backups,
+      rate_limits=rate_limits,
+      credits_=credits_,
+    )
+
+    graph_limits_response.additional_properties = d
+    return graph_limits_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/initial_entity_data.py

@@ -11,18 +11,21 @@ T = TypeVar("T", bound="InitialEntityData")
 
 @_attrs_define
 class InitialEntityData:
-  """Initial entity data for graph creation.
-
-  Attributes:
-      name (str): Entity name
-      uri (str): Entity website or URI
-      cik (Union[None, Unset, str]): CIK number for SEC filings
-      sic (Union[None, Unset, str]): SIC code
-      sic_description (Union[None, Unset, str]): SIC description
-      category (Union[None, Unset, str]): Business category
-      state_of_incorporation (Union[None, Unset, str]): State of incorporation
-      fiscal_year_end (Union[None, Unset, str]): Fiscal year end (MMDD)
-      ein (Union[None, Unset, str]): Employer Identification Number
+  """Initial entity data for entity-focused graph creation.
+
+  When creating an entity graph with an initial entity node, this model defines
+  the entity's identifying information and metadata.
+
+      Attributes:
+          name (str): Entity name
+          uri (str): Entity website or URI
+          cik (Union[None, Unset, str]): CIK number for SEC filings
+          sic (Union[None, Unset, str]): SIC code
+          sic_description (Union[None, Unset, str]): SIC description
+          category (Union[None, Unset, str]): Business category
+          state_of_incorporation (Union[None, Unset, str]): State of incorporation
+          fiscal_year_end (Union[None, Unset, str]): Fiscal year end (MMDD)
+          ein (Union[None, Unset, str]): Employer Identification Number
   """
 
   name: str

robosystems_client/models/query_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="QueryLimits")
+
+
+@_attrs_define
+class QueryLimits:
+  """Query operation limits.
+
+  Attributes:
+      max_timeout_seconds (int): Maximum query timeout in seconds
+      chunk_size (int): Maximum chunk size for result streaming
+      max_rows_per_query (int): Maximum rows returned per query
+      concurrent_queries (int): Maximum concurrent queries allowed
+  """
+
+  max_timeout_seconds: int
+  chunk_size: int
+  max_rows_per_query: int
+  concurrent_queries: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_timeout_seconds = self.max_timeout_seconds
+
+    chunk_size = self.chunk_size
+
+    max_rows_per_query = self.max_rows_per_query
+
+    concurrent_queries = self.concurrent_queries
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_timeout_seconds": max_timeout_seconds,
+        "chunk_size": chunk_size,
+        "max_rows_per_query": max_rows_per_query,
+        "concurrent_queries": concurrent_queries,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_timeout_seconds = d.pop("max_timeout_seconds")
+
+    chunk_size = d.pop("chunk_size")
+
+    max_rows_per_query = d.pop("max_rows_per_query")
+
+    concurrent_queries = d.pop("concurrent_queries")
+
+    query_limits = cls(
+      max_timeout_seconds=max_timeout_seconds,
+      chunk_size=chunk_size,
+      max_rows_per_query=max_rows_per_query,
+      concurrent_queries=concurrent_queries,
+    )
+
+    query_limits.additional_properties = d
+    return query_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/rate_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="RateLimits")
+
+
+@_attrs_define
+class RateLimits:
+  """API rate limits.
+
+  Attributes:
+      requests_per_minute (int): Requests per minute limit
+      requests_per_hour (int): Requests per hour limit
+      burst_capacity (int): Burst capacity for short spikes
+  """
+
+  requests_per_minute: int
+  requests_per_hour: int
+  burst_capacity: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    requests_per_minute = self.requests_per_minute
+
+    requests_per_hour = self.requests_per_hour
+
+    burst_capacity = self.burst_capacity
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "requests_per_minute": requests_per_minute,
+        "requests_per_hour": requests_per_hour,
+        "burst_capacity": burst_capacity,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    requests_per_minute = d.pop("requests_per_minute")
+
+    requests_per_hour = d.pop("requests_per_hour")
+
+    burst_capacity = d.pop("burst_capacity")
+
+    rate_limits = cls(
+      requests_per_minute=requests_per_minute,
+      requests_per_hour=requests_per_hour,
+      burst_capacity=burst_capacity,
+    )
+
+    rate_limits.additional_properties = d
+    return rate_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