robosystems-client 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

robosystems_client/models/subgraph_response.py

@@ -0,0 +1,279 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.subgraph_type import SubgraphType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.subgraph_response_metadata_type_0 import SubgraphResponseMetadataType0
+
+
+T = TypeVar("T", bound="SubgraphResponse")
+
+
+@_attrs_define
+class SubgraphResponse:
+  """Response model for a subgraph.
+
+  Attributes:
+      graph_id (str): Full subgraph identifier (e.g., kg123_dev)
+      parent_graph_id (str): Parent graph identifier
+      subgraph_index (int): Numeric index of the subgraph
+      subgraph_name (str): Alphanumeric name of the subgraph
+      display_name (str): Human-readable display name
+      subgraph_type (SubgraphType): Types of subgraphs.
+      status (str): Current status of the subgraph
+      created_at (datetime.datetime): When the subgraph was created
+      updated_at (datetime.datetime): When the subgraph was last updated
+      description (Union[None, Unset, str]): Description of the subgraph's purpose
+      size_mb (Union[None, Unset, float]): Size of the subgraph database in megabytes
+      node_count (Union[None, Unset, int]): Number of nodes in the subgraph
+      edge_count (Union[None, Unset, int]): Number of edges in the subgraph
+      last_accessed (Union[None, Unset, datetime.datetime]): When the subgraph was last accessed
+      metadata (Union['SubgraphResponseMetadataType0', None, Unset]): Additional metadata for the subgraph
+  """
+
+  graph_id: str
+  parent_graph_id: str
+  subgraph_index: int
+  subgraph_name: str
+  display_name: str
+  subgraph_type: SubgraphType
+  status: str
+  created_at: datetime.datetime
+  updated_at: datetime.datetime
+  description: Union[None, Unset, str] = UNSET
+  size_mb: Union[None, Unset, float] = UNSET
+  node_count: Union[None, Unset, int] = UNSET
+  edge_count: Union[None, Unset, int] = UNSET
+  last_accessed: Union[None, Unset, datetime.datetime] = UNSET
+  metadata: Union["SubgraphResponseMetadataType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.subgraph_response_metadata_type_0 import SubgraphResponseMetadataType0
+
+    graph_id = self.graph_id
+
+    parent_graph_id = self.parent_graph_id
+
+    subgraph_index = self.subgraph_index
+
+    subgraph_name = self.subgraph_name
+
+    display_name = self.display_name
+
+    subgraph_type = self.subgraph_type.value
+
+    status = self.status
+
+    created_at = self.created_at.isoformat()
+
+    updated_at = self.updated_at.isoformat()
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    size_mb: Union[None, Unset, float]
+    if isinstance(self.size_mb, Unset):
+      size_mb = UNSET
+    else:
+      size_mb = self.size_mb
+
+    node_count: Union[None, Unset, int]
+    if isinstance(self.node_count, Unset):
+      node_count = UNSET
+    else:
+      node_count = self.node_count
+
+    edge_count: Union[None, Unset, int]
+    if isinstance(self.edge_count, Unset):
+      edge_count = UNSET
+    else:
+      edge_count = self.edge_count
+
+    last_accessed: Union[None, Unset, str]
+    if isinstance(self.last_accessed, Unset):
+      last_accessed = UNSET
+    elif isinstance(self.last_accessed, datetime.datetime):
+      last_accessed = self.last_accessed.isoformat()
+    else:
+      last_accessed = self.last_accessed
+
+    metadata: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.metadata, Unset):
+      metadata = UNSET
+    elif isinstance(self.metadata, SubgraphResponseMetadataType0):
+      metadata = self.metadata.to_dict()
+    else:
+      metadata = self.metadata
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "parent_graph_id": parent_graph_id,
+        "subgraph_index": subgraph_index,
+        "subgraph_name": subgraph_name,
+        "display_name": display_name,
+        "subgraph_type": subgraph_type,
+        "status": status,
+        "created_at": created_at,
+        "updated_at": updated_at,
+      }
+    )
+    if description is not UNSET:
+      field_dict["description"] = description
+    if size_mb is not UNSET:
+      field_dict["size_mb"] = size_mb
+    if node_count is not UNSET:
+      field_dict["node_count"] = node_count
+    if edge_count is not UNSET:
+      field_dict["edge_count"] = edge_count
+    if last_accessed is not UNSET:
+      field_dict["last_accessed"] = last_accessed
+    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.subgraph_response_metadata_type_0 import SubgraphResponseMetadataType0
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    parent_graph_id = d.pop("parent_graph_id")
+
+    subgraph_index = d.pop("subgraph_index")
+
+    subgraph_name = d.pop("subgraph_name")
+
+    display_name = d.pop("display_name")
+
+    subgraph_type = SubgraphType(d.pop("subgraph_type"))
+
+    status = d.pop("status")
+
+    created_at = isoparse(d.pop("created_at"))
+
+    updated_at = isoparse(d.pop("updated_at"))
+
+    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_size_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)
+
+    size_mb = _parse_size_mb(d.pop("size_mb", UNSET))
+
+    def _parse_node_count(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)
+
+    node_count = _parse_node_count(d.pop("node_count", UNSET))
+
+    def _parse_edge_count(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)
+
+    edge_count = _parse_edge_count(d.pop("edge_count", UNSET))
+
+    def _parse_last_accessed(data: object) -> Union[None, Unset, datetime.datetime]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        last_accessed_type_0 = isoparse(data)
+
+        return last_accessed_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, datetime.datetime], data)
+
+    last_accessed = _parse_last_accessed(d.pop("last_accessed", UNSET))
+
+    def _parse_metadata(
+      data: object,
+    ) -> Union["SubgraphResponseMetadataType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        metadata_type_0 = SubgraphResponseMetadataType0.from_dict(data)
+
+        return metadata_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SubgraphResponseMetadataType0", None, Unset], data)
+
+    metadata = _parse_metadata(d.pop("metadata", UNSET))
+
+    subgraph_response = cls(
+      graph_id=graph_id,
+      parent_graph_id=parent_graph_id,
+      subgraph_index=subgraph_index,
+      subgraph_name=subgraph_name,
+      display_name=display_name,
+      subgraph_type=subgraph_type,
+      status=status,
+      created_at=created_at,
+      updated_at=updated_at,
+      description=description,
+      size_mb=size_mb,
+      node_count=node_count,
+      edge_count=edge_count,
+      last_accessed=last_accessed,
+      metadata=metadata,
+    )
+
+    subgraph_response.additional_properties = d
+    return subgraph_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/subgraph_response_metadata_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="SubgraphResponseMetadataType0")
+
+
+@_attrs_define
+class SubgraphResponseMetadataType0:
+  """ """
+
+  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)
+    subgraph_response_metadata_type_0 = cls()
+
+    subgraph_response_metadata_type_0.additional_properties = d
+    return subgraph_response_metadata_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/subgraph_summary.py

@@ -0,0 +1,155 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.subgraph_type import SubgraphType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SubgraphSummary")
+
+
+@_attrs_define
+class SubgraphSummary:
+  """Summary model for listing subgraphs.
+
+  Attributes:
+      graph_id (str): Full subgraph identifier
+      subgraph_name (str): Alphanumeric name
+      display_name (str): Human-readable name
+      subgraph_type (SubgraphType): Types of subgraphs.
+      status (str): Current status
+      created_at (datetime.datetime): Creation timestamp
+      size_mb (Union[None, Unset, float]): Size in megabytes
+      last_accessed (Union[None, Unset, datetime.datetime]): Last access timestamp
+  """
+
+  graph_id: str
+  subgraph_name: str
+  display_name: str
+  subgraph_type: SubgraphType
+  status: str
+  created_at: datetime.datetime
+  size_mb: Union[None, Unset, float] = UNSET
+  last_accessed: Union[None, Unset, datetime.datetime] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    subgraph_name = self.subgraph_name
+
+    display_name = self.display_name
+
+    subgraph_type = self.subgraph_type.value
+
+    status = self.status
+
+    created_at = self.created_at.isoformat()
+
+    size_mb: Union[None, Unset, float]
+    if isinstance(self.size_mb, Unset):
+      size_mb = UNSET
+    else:
+      size_mb = self.size_mb
+
+    last_accessed: Union[None, Unset, str]
+    if isinstance(self.last_accessed, Unset):
+      last_accessed = UNSET
+    elif isinstance(self.last_accessed, datetime.datetime):
+      last_accessed = self.last_accessed.isoformat()
+    else:
+      last_accessed = self.last_accessed
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "subgraph_name": subgraph_name,
+        "display_name": display_name,
+        "subgraph_type": subgraph_type,
+        "status": status,
+        "created_at": created_at,
+      }
+    )
+    if size_mb is not UNSET:
+      field_dict["size_mb"] = size_mb
+    if last_accessed is not UNSET:
+      field_dict["last_accessed"] = last_accessed
+
+    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")
+
+    subgraph_name = d.pop("subgraph_name")
+
+    display_name = d.pop("display_name")
+
+    subgraph_type = SubgraphType(d.pop("subgraph_type"))
+
+    status = d.pop("status")
+
+    created_at = isoparse(d.pop("created_at"))
+
+    def _parse_size_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)
+
+    size_mb = _parse_size_mb(d.pop("size_mb", UNSET))
+
+    def _parse_last_accessed(data: object) -> Union[None, Unset, datetime.datetime]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        last_accessed_type_0 = isoparse(data)
+
+        return last_accessed_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, datetime.datetime], data)
+
+    last_accessed = _parse_last_accessed(d.pop("last_accessed", UNSET))
+
+    subgraph_summary = cls(
+      graph_id=graph_id,
+      subgraph_name=subgraph_name,
+      display_name=display_name,
+      subgraph_type=subgraph_type,
+      status=status,
+      created_at=created_at,
+      size_mb=size_mb,
+      last_accessed=last_accessed,
+    )
+
+    subgraph_summary.additional_properties = d
+    return subgraph_summary
+
+  @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/subgraph_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SubgraphType(str, Enum):
+  MEMORY = "memory"
+  STATIC = "static"
+  TEMPORAL = "temporal"
+  VERSIONED = "versioned"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/url_copy_request.py

@@ -0,0 +1,157 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.url_copy_request_file_format import URLCopyRequestFileFormat
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.url_copy_request_headers_type_0 import URLCopyRequestHeadersType0
+
+
+T = TypeVar("T", bound="URLCopyRequest")
+
+
+@_attrs_define
+class URLCopyRequest:
+  """Request model for URL copy operations (future).
+
+  Attributes:
+      table_name (str): Target Kuzu table name
+      url (str): HTTP(S) URL to the data file
+      file_format (URLCopyRequestFileFormat): File format of the URL data
+      ignore_errors (Union[Unset, bool]): Skip duplicate/invalid rows (enables upsert-like behavior) Default: True.
+      extended_timeout (Union[Unset, bool]): Use extended timeout for large datasets Default: False.
+      validate_schema (Union[Unset, bool]): Validate source schema against target table Default: True.
+      source_type (Union[Literal['url'], Unset]): Source type identifier Default: 'url'.
+      headers (Union['URLCopyRequestHeadersType0', None, Unset]): Optional HTTP headers for authentication
+  """
+
+  table_name: str
+  url: str
+  file_format: URLCopyRequestFileFormat
+  ignore_errors: Union[Unset, bool] = True
+  extended_timeout: Union[Unset, bool] = False
+  validate_schema: Union[Unset, bool] = True
+  source_type: Union[Literal["url"], Unset] = "url"
+  headers: Union["URLCopyRequestHeadersType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.url_copy_request_headers_type_0 import URLCopyRequestHeadersType0
+
+    table_name = self.table_name
+
+    url = self.url
+
+    file_format = self.file_format.value
+
+    ignore_errors = self.ignore_errors
+
+    extended_timeout = self.extended_timeout
+
+    validate_schema = self.validate_schema
+
+    source_type = self.source_type
+
+    headers: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.headers, Unset):
+      headers = UNSET
+    elif isinstance(self.headers, URLCopyRequestHeadersType0):
+      headers = self.headers.to_dict()
+    else:
+      headers = self.headers
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "table_name": table_name,
+        "url": url,
+        "file_format": file_format,
+      }
+    )
+    if ignore_errors is not UNSET:
+      field_dict["ignore_errors"] = ignore_errors
+    if extended_timeout is not UNSET:
+      field_dict["extended_timeout"] = extended_timeout
+    if validate_schema is not UNSET:
+      field_dict["validate_schema"] = validate_schema
+    if source_type is not UNSET:
+      field_dict["source_type"] = source_type
+    if headers is not UNSET:
+      field_dict["headers"] = headers
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.url_copy_request_headers_type_0 import URLCopyRequestHeadersType0
+
+    d = dict(src_dict)
+    table_name = d.pop("table_name")
+
+    url = d.pop("url")
+
+    file_format = URLCopyRequestFileFormat(d.pop("file_format"))
+
+    ignore_errors = d.pop("ignore_errors", UNSET)
+
+    extended_timeout = d.pop("extended_timeout", UNSET)
+
+    validate_schema = d.pop("validate_schema", UNSET)
+
+    source_type = cast(Union[Literal["url"], Unset], d.pop("source_type", UNSET))
+    if source_type != "url" and not isinstance(source_type, Unset):
+      raise ValueError(f"source_type must match const 'url', got '{source_type}'")
+
+    def _parse_headers(
+      data: object,
+    ) -> Union["URLCopyRequestHeadersType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        headers_type_0 = URLCopyRequestHeadersType0.from_dict(data)
+
+        return headers_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["URLCopyRequestHeadersType0", None, Unset], data)
+
+    headers = _parse_headers(d.pop("headers", UNSET))
+
+    url_copy_request = cls(
+      table_name=table_name,
+      url=url,
+      file_format=file_format,
+      ignore_errors=ignore_errors,
+      extended_timeout=extended_timeout,
+      validate_schema=validate_schema,
+      source_type=source_type,
+      headers=headers,
+    )
+
+    url_copy_request.additional_properties = d
+    return url_copy_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/url_copy_request_file_format.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class URLCopyRequestFileFormat(str, Enum):
+  CSV = "csv"
+  JSON = "json"
+  PARQUET = "parquet"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/url_copy_request_headers_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="URLCopyRequestHeadersType0")
+
+
+@_attrs_define
+class URLCopyRequestHeadersType0:
+  """ """
+
+  additional_properties: dict[str, str] = _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)
+    url_copy_request_headers_type_0 = cls()
+
+    url_copy_request_headers_type_0.additional_properties = d
+    return url_copy_request_headers_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> str:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: str) -> 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