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

robosystems_client/models/copy_response.py

@@ -0,0 +1,223 @@
+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 ..models.copy_response_status import CopyResponseStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.copy_response_error_details_type_0 import CopyResponseErrorDetailsType0
+
+
+T = TypeVar("T", bound="CopyResponse")
+
+
+@_attrs_define
+class CopyResponse:
+  """Response model for copy operations.
+
+  Attributes:
+      status (CopyResponseStatus): Operation status
+      source_type (str): Type of source that was copied from
+      execution_time_ms (float): Total execution time in milliseconds
+      message (str): Human-readable status message
+      rows_imported (Union[None, Unset, int]): Number of rows successfully imported
+      rows_skipped (Union[None, Unset, int]): Number of rows skipped due to errors (when ignore_errors=true)
+      warnings (Union[None, Unset, list[str]]): List of warnings encountered during import
+      error_details (Union['CopyResponseErrorDetailsType0', None, Unset]): Detailed error information if operation
+          failed
+      bytes_processed (Union[None, Unset, int]): Total bytes processed from source
+  """
+
+  status: CopyResponseStatus
+  source_type: str
+  execution_time_ms: float
+  message: str
+  rows_imported: Union[None, Unset, int] = UNSET
+  rows_skipped: Union[None, Unset, int] = UNSET
+  warnings: Union[None, Unset, list[str]] = UNSET
+  error_details: Union["CopyResponseErrorDetailsType0", None, Unset] = UNSET
+  bytes_processed: Union[None, Unset, int] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.copy_response_error_details_type_0 import (
+      CopyResponseErrorDetailsType0,
+    )
+
+    status = self.status.value
+
+    source_type = self.source_type
+
+    execution_time_ms = self.execution_time_ms
+
+    message = self.message
+
+    rows_imported: Union[None, Unset, int]
+    if isinstance(self.rows_imported, Unset):
+      rows_imported = UNSET
+    else:
+      rows_imported = self.rows_imported
+
+    rows_skipped: Union[None, Unset, int]
+    if isinstance(self.rows_skipped, Unset):
+      rows_skipped = UNSET
+    else:
+      rows_skipped = self.rows_skipped
+
+    warnings: Union[None, Unset, list[str]]
+    if isinstance(self.warnings, Unset):
+      warnings = UNSET
+    elif isinstance(self.warnings, list):
+      warnings = self.warnings
+
+    else:
+      warnings = self.warnings
+
+    error_details: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.error_details, Unset):
+      error_details = UNSET
+    elif isinstance(self.error_details, CopyResponseErrorDetailsType0):
+      error_details = self.error_details.to_dict()
+    else:
+      error_details = self.error_details
+
+    bytes_processed: Union[None, Unset, int]
+    if isinstance(self.bytes_processed, Unset):
+      bytes_processed = UNSET
+    else:
+      bytes_processed = self.bytes_processed
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "status": status,
+        "source_type": source_type,
+        "execution_time_ms": execution_time_ms,
+        "message": message,
+      }
+    )
+    if rows_imported is not UNSET:
+      field_dict["rows_imported"] = rows_imported
+    if rows_skipped is not UNSET:
+      field_dict["rows_skipped"] = rows_skipped
+    if warnings is not UNSET:
+      field_dict["warnings"] = warnings
+    if error_details is not UNSET:
+      field_dict["error_details"] = error_details
+    if bytes_processed is not UNSET:
+      field_dict["bytes_processed"] = bytes_processed
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.copy_response_error_details_type_0 import (
+      CopyResponseErrorDetailsType0,
+    )
+
+    d = dict(src_dict)
+    status = CopyResponseStatus(d.pop("status"))
+
+    source_type = d.pop("source_type")
+
+    execution_time_ms = d.pop("execution_time_ms")
+
+    message = d.pop("message")
+
+    def _parse_rows_imported(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)
+
+    rows_imported = _parse_rows_imported(d.pop("rows_imported", UNSET))
+
+    def _parse_rows_skipped(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)
+
+    rows_skipped = _parse_rows_skipped(d.pop("rows_skipped", UNSET))
+
+    def _parse_warnings(data: object) -> Union[None, Unset, list[str]]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        warnings_type_0 = cast(list[str], data)
+
+        return warnings_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[str]], data)
+
+    warnings = _parse_warnings(d.pop("warnings", UNSET))
+
+    def _parse_error_details(
+      data: object,
+    ) -> Union["CopyResponseErrorDetailsType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        error_details_type_0 = CopyResponseErrorDetailsType0.from_dict(data)
+
+        return error_details_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["CopyResponseErrorDetailsType0", None, Unset], data)
+
+    error_details = _parse_error_details(d.pop("error_details", UNSET))
+
+    def _parse_bytes_processed(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)
+
+    bytes_processed = _parse_bytes_processed(d.pop("bytes_processed", UNSET))
+
+    copy_response = cls(
+      status=status,
+      source_type=source_type,
+      execution_time_ms=execution_time_ms,
+      message=message,
+      rows_imported=rows_imported,
+      rows_skipped=rows_skipped,
+      warnings=warnings,
+      error_details=error_details,
+      bytes_processed=bytes_processed,
+    )
+
+    copy_response.additional_properties = d
+    return copy_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/{kuzu_backup_health_response_kuzubackuphealth.py → copy_response_error_details_type_0.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="KuzuBackupHealthResponseKuzubackuphealth")
+T = TypeVar("T", bound="CopyResponseErrorDetailsType0")
 
 
 @_attrs_define
-class KuzuBackupHealthResponseKuzubackuphealth:
+class CopyResponseErrorDetailsType0:
   """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +22,10 @@ class KuzuBackupHealthResponseKuzubackuphealth:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    kuzu_backup_health_response_kuzubackuphealth = cls()
+    copy_response_error_details_type_0 = cls()
 
-    kuzu_backup_health_response_kuzubackuphealth.additional_properties = d
-    return kuzu_backup_health_response_kuzubackuphealth
+    copy_response_error_details_type_0.additional_properties = d
+    return copy_response_error_details_type_0
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/copy_response_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CopyResponseStatus(str, Enum):
+  COMPLETED = "completed"
+  FAILED = "failed"
+  PARTIAL = "partial"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/custom_schema_definition.py

@@ -31,8 +31,8 @@ class CustomSchemaDefinition:
       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'}]}].
+          'INT64'}]}, {'name': 'Warehouse', 'properties': [{'name': 'identifier', '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'}].

robosystems_client/models/data_frame_copy_request.py

@@ -0,0 +1,125 @@
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.data_frame_copy_request_format import DataFrameCopyRequestFormat
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DataFrameCopyRequest")
+
+
+@_attrs_define
+class DataFrameCopyRequest:
+  """Request model for DataFrame copy operations (future).
+
+  Attributes:
+      table_name (str): Target Kuzu table name
+      data_reference (str): Reference to uploaded DataFrame 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['dataframe'], Unset]): Source type identifier Default: 'dataframe'.
+      format_ (Union[Unset, DataFrameCopyRequestFormat]): DataFrame format Default: DataFrameCopyRequestFormat.PANDAS.
+  """
+
+  table_name: str
+  data_reference: str
+  ignore_errors: Union[Unset, bool] = True
+  extended_timeout: Union[Unset, bool] = False
+  validate_schema: Union[Unset, bool] = True
+  source_type: Union[Literal["dataframe"], Unset] = "dataframe"
+  format_: Union[Unset, DataFrameCopyRequestFormat] = DataFrameCopyRequestFormat.PANDAS
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    table_name = self.table_name
+
+    data_reference = self.data_reference
+
+    ignore_errors = self.ignore_errors
+
+    extended_timeout = self.extended_timeout
+
+    validate_schema = self.validate_schema
+
+    source_type = self.source_type
+
+    format_: Union[Unset, str] = UNSET
+    if not isinstance(self.format_, Unset):
+      format_ = self.format_.value
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "table_name": table_name,
+        "data_reference": data_reference,
+      }
+    )
+    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 format_ is not UNSET:
+      field_dict["format"] = format_
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    table_name = d.pop("table_name")
+
+    data_reference = d.pop("data_reference")
+
+    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["dataframe"], Unset], d.pop("source_type", UNSET))
+    if source_type != "dataframe" and not isinstance(source_type, Unset):
+      raise ValueError(f"source_type must match const 'dataframe', got '{source_type}'")
+
+    _format_ = d.pop("format", UNSET)
+    format_: Union[Unset, DataFrameCopyRequestFormat]
+    if isinstance(_format_, Unset):
+      format_ = UNSET
+    else:
+      format_ = DataFrameCopyRequestFormat(_format_)
+
+    data_frame_copy_request = cls(
+      table_name=table_name,
+      data_reference=data_reference,
+      ignore_errors=ignore_errors,
+      extended_timeout=extended_timeout,
+      validate_schema=validate_schema,
+      source_type=source_type,
+      format_=format_,
+    )
+
+    data_frame_copy_request.additional_properties = d
+    return data_frame_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/data_frame_copy_request_format.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class DataFrameCopyRequestFormat(str, Enum):
+  ARROW = "arrow"
+  PANDAS = "pandas"
+  POLARS = "polars"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/get_graph_limits_response_getgraphlimits.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="GetGraphLimitsResponseGetgraphlimits")
+
+
+@_attrs_define
+class GetGraphLimitsResponseGetgraphlimits:
+  """ """
+
+  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)
+    get_graph_limits_response_getgraphlimits = cls()
+
+    get_graph_limits_response_getgraphlimits.additional_properties = d
+    return get_graph_limits_response_getgraphlimits
+
+  @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