robosystems-client 0.2.15__py3-none-any.whl → 0.2.16__py3-none-any.whl

robosystems_client/models/list_subgraphs_response.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -24,9 +26,9 @@ class ListSubgraphsResponse:
       subgraphs_enabled (bool): Whether subgraphs are enabled for this tier (requires Kuzu Large/XLarge or Neo4j
           Enterprise XLarge)
       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
+      subgraphs (list[SubgraphSummary]): List of subgraphs
+      max_subgraphs (int | None | Unset): Maximum allowed subgraphs for this tier (None = unlimited)
+      total_size_mb (float | None | Unset): Combined size of all subgraphs in megabytes
   """
 
   parent_graph_id: str
@@ -34,9 +36,9 @@ class ListSubgraphsResponse:
   parent_graph_tier: str
   subgraphs_enabled: bool
   subgraph_count: int
-  subgraphs: list["SubgraphSummary"]
-  max_subgraphs: Union[None, Unset, int] = UNSET
-  total_size_mb: Union[None, Unset, float] = UNSET
+  subgraphs: list[SubgraphSummary]
+  max_subgraphs: int | None | Unset = UNSET
+  total_size_mb: float | None | Unset = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -55,13 +57,13 @@ class ListSubgraphsResponse:
       subgraphs_item = subgraphs_item_data.to_dict()
       subgraphs.append(subgraphs_item)
 
-    max_subgraphs: Union[None, Unset, int]
+    max_subgraphs: int | None | Unset
     if isinstance(self.max_subgraphs, Unset):
       max_subgraphs = UNSET
     else:
       max_subgraphs = self.max_subgraphs
 
-    total_size_mb: Union[None, Unset, float]
+    total_size_mb: float | None | Unset
     if isinstance(self.total_size_mb, Unset):
       total_size_mb = UNSET
     else:
@@ -108,21 +110,21 @@ class ListSubgraphsResponse:
 
       subgraphs.append(subgraphs_item)
 
-    def _parse_max_subgraphs(data: object) -> Union[None, Unset, int]:
+    def _parse_max_subgraphs(data: object) -> int | None | Unset:
       if data is None:
         return data
       if isinstance(data, Unset):
         return data
-      return cast(Union[None, Unset, int], data)
+      return cast(int | None | Unset, data)
 
     max_subgraphs = _parse_max_subgraphs(d.pop("max_subgraphs", UNSET))
 
-    def _parse_total_size_mb(data: object) -> Union[None, Unset, float]:
+    def _parse_total_size_mb(data: object) -> float | None | Unset:
       if data is None:
         return data
       if isinstance(data, Unset):
         return data
-      return cast(Union[None, Unset, float], data)
+      return cast(float | None | Unset, data)
 
     total_size_mb = _parse_total_size_mb(d.pop("total_size_mb", UNSET))
 

robosystems_client/models/list_table_files_response.py

@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar, 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.file_info import FileInfo
 
@@ -16,24 +20,22 @@ class ListTableFilesResponse:
   """
   Attributes:
       graph_id (str): Graph database identifier
-      table_name (str): Table name
-      files (list['FileInfo']): List of files in the table
+      files (list[FileInfo]): List of files in the table
       total_files (int): Total number of files
       total_size_bytes (int): Total size of all files in bytes
+      table_name (None | str | Unset): Table name (null if listing all files in graph)
   """
 
   graph_id: str
-  table_name: str
-  files: list["FileInfo"]
+  files: list[FileInfo]
   total_files: int
   total_size_bytes: int
+  table_name: None | str | Unset = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
     graph_id = self.graph_id
 
-    table_name = self.table_name
-
     files = []
     for files_item_data in self.files:
       files_item = files_item_data.to_dict()
@@ -43,17 +45,24 @@ class ListTableFilesResponse:
 
     total_size_bytes = self.total_size_bytes
 
+    table_name: None | str | Unset
+    if isinstance(self.table_name, Unset):
+      table_name = UNSET
+    else:
+      table_name = self.table_name
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
         "graph_id": graph_id,
-        "table_name": table_name,
         "files": files,
         "total_files": total_files,
         "total_size_bytes": total_size_bytes,
       }
     )
+    if table_name is not UNSET:
+      field_dict["table_name"] = table_name
 
     return field_dict
 
@@ -64,8 +73,6 @@ class ListTableFilesResponse:
     d = dict(src_dict)
     graph_id = d.pop("graph_id")
 
-    table_name = d.pop("table_name")
-
     files = []
     _files = d.pop("files")
     for files_item_data in _files:
@@ -77,12 +84,21 @@ class ListTableFilesResponse:
 
     total_size_bytes = d.pop("total_size_bytes")
 
+    def _parse_table_name(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    table_name = _parse_table_name(d.pop("table_name", UNSET))
+
     list_table_files_response = cls(
       graph_id=graph_id,
-      table_name=table_name,
       files=files,
       total_files=total_files,
       total_size_bytes=total_size_bytes,
+      table_name=table_name,
     )
 
     list_table_files_response.additional_properties = d

robosystems_client/models/login_request.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar
 

robosystems_client/models/logout_user_response_logoutuser.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar
 

robosystems_client/models/{bulk_ingest_request.py → materialize_request.py}

@@ -1,50 +1,60 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar
 
 from attrs import define as _attrs_define
 
 from ..types import UNSET, Unset
 
-T = TypeVar("T", bound="BulkIngestRequest")
+T = TypeVar("T", bound="MaterializeRequest")
 
 
 @_attrs_define
-class BulkIngestRequest:
+class MaterializeRequest:
   """
   Attributes:
-      ignore_errors (Union[Unset, bool]): Continue ingestion on row errors Default: True.
-      rebuild (Union[Unset, bool]): Rebuild graph database from scratch before ingestion. Safe operation - staged data
-          is the source of truth, graph can always be regenerated. Default: False.
+      force (bool | Unset): Force materialization even if graph is not stale Default: False.
+      rebuild (bool | Unset): Delete and recreate graph database before materialization Default: False.
+      ignore_errors (bool | Unset): Continue ingestion on row errors Default: True.
   """
 
-  ignore_errors: Union[Unset, bool] = True
-  rebuild: Union[Unset, bool] = False
+  force: bool | Unset = False
+  rebuild: bool | Unset = False
+  ignore_errors: bool | Unset = True
 
   def to_dict(self) -> dict[str, Any]:
-    ignore_errors = self.ignore_errors
+    force = self.force
 
     rebuild = self.rebuild
 
+    ignore_errors = self.ignore_errors
+
     field_dict: dict[str, Any] = {}
 
     field_dict.update({})
-    if ignore_errors is not UNSET:
-      field_dict["ignore_errors"] = ignore_errors
+    if force is not UNSET:
+      field_dict["force"] = force
     if rebuild is not UNSET:
       field_dict["rebuild"] = rebuild
+    if ignore_errors is not UNSET:
+      field_dict["ignore_errors"] = ignore_errors
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    ignore_errors = d.pop("ignore_errors", UNSET)
+    force = d.pop("force", UNSET)
 
     rebuild = d.pop("rebuild", UNSET)
 
-    bulk_ingest_request = cls(
-      ignore_errors=ignore_errors,
+    ignore_errors = d.pop("ignore_errors", UNSET)
+
+    materialize_request = cls(
+      force=force,
       rebuild=rebuild,
+      ignore_errors=ignore_errors,
     )
 
-    return bulk_ingest_request
+    return materialize_request

robosystems_client/models/materialize_response.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MaterializeResponse")
+
+
+@_attrs_define
+class MaterializeResponse:
+  """
+  Attributes:
+      status (str): Materialization status
+      graph_id (str): Graph database identifier
+      was_stale (bool): Whether graph was stale before materialization
+      tables_materialized (list[str]): List of tables successfully materialized
+      total_rows (int): Total rows materialized across all tables
+      execution_time_ms (float): Total materialization time
+      message (str): Human-readable status message
+      stale_reason (None | str | Unset): Reason graph was stale
+  """
+
+  status: str
+  graph_id: str
+  was_stale: bool
+  tables_materialized: list[str]
+  total_rows: int
+  execution_time_ms: float
+  message: str
+  stale_reason: None | str | Unset = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    status = self.status
+
+    graph_id = self.graph_id
+
+    was_stale = self.was_stale
+
+    tables_materialized = self.tables_materialized
+
+    total_rows = self.total_rows
+
+    execution_time_ms = self.execution_time_ms
+
+    message = self.message
+
+    stale_reason: None | str | Unset
+    if isinstance(self.stale_reason, Unset):
+      stale_reason = UNSET
+    else:
+      stale_reason = self.stale_reason
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "status": status,
+        "graph_id": graph_id,
+        "was_stale": was_stale,
+        "tables_materialized": tables_materialized,
+        "total_rows": total_rows,
+        "execution_time_ms": execution_time_ms,
+        "message": message,
+      }
+    )
+    if stale_reason is not UNSET:
+      field_dict["stale_reason"] = stale_reason
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    status = d.pop("status")
+
+    graph_id = d.pop("graph_id")
+
+    was_stale = d.pop("was_stale")
+
+    tables_materialized = cast(list[str], d.pop("tables_materialized"))
+
+    total_rows = d.pop("total_rows")
+
+    execution_time_ms = d.pop("execution_time_ms")
+
+    message = d.pop("message")
+
+    def _parse_stale_reason(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    stale_reason = _parse_stale_reason(d.pop("stale_reason", UNSET))
+
+    materialize_response = cls(
+      status=status,
+      graph_id=graph_id,
+      was_stale=was_stale,
+      tables_materialized=tables_materialized,
+      total_rows=total_rows,
+      execution_time_ms=execution_time_ms,
+      message=message,
+      stale_reason=stale_reason,
+    )
+
+    materialize_response.additional_properties = d
+    return materialize_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/materialize_status_response.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MaterializeStatusResponse")
+
+
+@_attrs_define
+class MaterializeStatusResponse:
+  """
+  Attributes:
+      graph_id (str): Graph database identifier
+      is_stale (bool): Whether graph is currently stale
+      message (str): Human-readable status summary
+      stale_reason (None | str | Unset): Reason for staleness if applicable
+      stale_since (None | str | Unset): When graph became stale (ISO timestamp)
+      last_materialized_at (None | str | Unset): When graph was last materialized (ISO timestamp)
+      materialization_count (int | Unset): Total number of materializations performed Default: 0.
+      hours_since_materialization (float | None | Unset): Hours since last materialization
+  """
+
+  graph_id: str
+  is_stale: bool
+  message: str
+  stale_reason: None | str | Unset = UNSET
+  stale_since: None | str | Unset = UNSET
+  last_materialized_at: None | str | Unset = UNSET
+  materialization_count: int | Unset = 0
+  hours_since_materialization: float | None | Unset = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    is_stale = self.is_stale
+
+    message = self.message
+
+    stale_reason: None | str | Unset
+    if isinstance(self.stale_reason, Unset):
+      stale_reason = UNSET
+    else:
+      stale_reason = self.stale_reason
+
+    stale_since: None | str | Unset
+    if isinstance(self.stale_since, Unset):
+      stale_since = UNSET
+    else:
+      stale_since = self.stale_since
+
+    last_materialized_at: None | str | Unset
+    if isinstance(self.last_materialized_at, Unset):
+      last_materialized_at = UNSET
+    else:
+      last_materialized_at = self.last_materialized_at
+
+    materialization_count = self.materialization_count
+
+    hours_since_materialization: float | None | Unset
+    if isinstance(self.hours_since_materialization, Unset):
+      hours_since_materialization = UNSET
+    else:
+      hours_since_materialization = self.hours_since_materialization
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "is_stale": is_stale,
+        "message": message,
+      }
+    )
+    if stale_reason is not UNSET:
+      field_dict["stale_reason"] = stale_reason
+    if stale_since is not UNSET:
+      field_dict["stale_since"] = stale_since
+    if last_materialized_at is not UNSET:
+      field_dict["last_materialized_at"] = last_materialized_at
+    if materialization_count is not UNSET:
+      field_dict["materialization_count"] = materialization_count
+    if hours_since_materialization is not UNSET:
+      field_dict["hours_since_materialization"] = hours_since_materialization
+
+    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")
+
+    is_stale = d.pop("is_stale")
+
+    message = d.pop("message")
+
+    def _parse_stale_reason(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    stale_reason = _parse_stale_reason(d.pop("stale_reason", UNSET))
+
+    def _parse_stale_since(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    stale_since = _parse_stale_since(d.pop("stale_since", UNSET))
+
+    def _parse_last_materialized_at(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    last_materialized_at = _parse_last_materialized_at(
+      d.pop("last_materialized_at", UNSET)
+    )
+
+    materialization_count = d.pop("materialization_count", UNSET)
+
+    def _parse_hours_since_materialization(data: object) -> float | None | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(float | None | Unset, data)
+
+    hours_since_materialization = _parse_hours_since_materialization(
+      d.pop("hours_since_materialization", UNSET)
+    )
+
+    materialize_status_response = cls(
+      graph_id=graph_id,
+      is_stale=is_stale,
+      message=message,
+      stale_reason=stale_reason,
+      stale_since=stale_since,
+      last_materialized_at=last_materialized_at,
+      materialization_count=materialization_count,
+      hours_since_materialization=hours_since_materialization,
+    )
+
+    materialize_status_response.additional_properties = d
+    return materialize_status_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/mcp_tool_call.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -19,17 +21,17 @@ class MCPToolCall:
 
   Attributes:
       name (str): Name of the MCP tool to execute
-      arguments (Union[Unset, MCPToolCallArguments]): Arguments to pass to the tool
+      arguments (MCPToolCallArguments | Unset): Arguments to pass to the tool
   """
 
   name: str
-  arguments: Union[Unset, "MCPToolCallArguments"] = UNSET
+  arguments: MCPToolCallArguments | Unset = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
     name = self.name
 
-    arguments: Union[Unset, dict[str, Any]] = UNSET
+    arguments: dict[str, Any] | Unset = UNSET
     if not isinstance(self.arguments, Unset):
       arguments = self.arguments.to_dict()
 
@@ -53,7 +55,7 @@ class MCPToolCall:
     name = d.pop("name")
 
     _arguments = d.pop("arguments", UNSET)
-    arguments: Union[Unset, MCPToolCallArguments]
+    arguments: MCPToolCallArguments | Unset
     if isinstance(_arguments, Unset):
       arguments = UNSET
     else:

robosystems_client/models/mcp_tool_call_arguments.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar
 

robosystems_client/models/mcp_tools_response.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, TypeVar
 
@@ -16,10 +18,10 @@ class MCPToolsResponse:
   """Response model for MCP tools listing.
 
   Attributes:
-      tools (list['MCPToolsResponseToolsItem']): List of available MCP tools with their schemas
+      tools (list[MCPToolsResponseToolsItem]): List of available MCP tools with their schemas
   """
 
-  tools: list["MCPToolsResponseToolsItem"]
+  tools: list[MCPToolsResponseToolsItem]
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:

robosystems_client/models/mcp_tools_response_tools_item.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar