robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/available_extension.py

@@ -0,0 +1,78 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AvailableExtension")
+
+
+@_attrs_define
+class AvailableExtension:
+  """
+  Attributes:
+      name (str):
+      description (str):
+      enabled (Union[Unset, bool]):  Default: False.
+  """
+
+  name: str
+  description: str
+  enabled: Union[Unset, bool] = False
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    name = self.name
+
+    description = self.description
+
+    enabled = self.enabled
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+        "description": description,
+      }
+    )
+    if enabled is not UNSET:
+      field_dict["enabled"] = enabled
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    name = d.pop("name")
+
+    description = d.pop("description")
+
+    enabled = d.pop("enabled", UNSET)
+
+    available_extension = cls(
+      name=name,
+      description=description,
+      enabled=enabled,
+    )
+
+    available_extension.additional_properties = d
+    return available_extension
+
+  @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/available_extensions_response.py

@@ -0,0 +1,73 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.available_extension import AvailableExtension
+
+
+T = TypeVar("T", bound="AvailableExtensionsResponse")
+
+
+@_attrs_define
+class AvailableExtensionsResponse:
+  """
+  Attributes:
+      extensions (list['AvailableExtension']):
+  """
+
+  extensions: list["AvailableExtension"]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    extensions = []
+    for extensions_item_data in self.extensions:
+      extensions_item = extensions_item_data.to_dict()
+      extensions.append(extensions_item)
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "extensions": extensions,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.available_extension import AvailableExtension
+
+    d = dict(src_dict)
+    extensions = []
+    _extensions = d.pop("extensions")
+    for extensions_item_data in _extensions:
+      extensions_item = AvailableExtension.from_dict(extensions_item_data)
+
+      extensions.append(extensions_item)
+
+    available_extensions_response = cls(
+      extensions=extensions,
+    )
+
+    available_extensions_response.additional_properties = d
+    return available_extensions_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/backup_create_request.py

@@ -0,0 +1,117 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BackupCreateRequest")
+
+
+@_attrs_define
+class BackupCreateRequest:
+  """Request model for creating a backup.
+
+  Attributes:
+      backup_format (Union[Unset, str]): Backup format - only 'full_dump' is supported (complete .kuzu database file)
+          Default: 'full_dump'.
+      backup_type (Union[Unset, str]): Backup type - only 'full' is supported Default: 'full'.
+      retention_days (Union[Unset, int]): Retention period in days Default: 90.
+      compression (Union[Unset, bool]): Enable compression (always enabled for optimal storage) Default: True.
+      encryption (Union[Unset, bool]): Enable encryption (encrypted backups cannot be downloaded) Default: False.
+      schedule (Union[None, Unset, str]): Optional cron schedule for automated backups
+  """
+
+  backup_format: Union[Unset, str] = "full_dump"
+  backup_type: Union[Unset, str] = "full"
+  retention_days: Union[Unset, int] = 90
+  compression: Union[Unset, bool] = True
+  encryption: Union[Unset, bool] = False
+  schedule: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    backup_format = self.backup_format
+
+    backup_type = self.backup_type
+
+    retention_days = self.retention_days
+
+    compression = self.compression
+
+    encryption = self.encryption
+
+    schedule: Union[None, Unset, str]
+    if isinstance(self.schedule, Unset):
+      schedule = UNSET
+    else:
+      schedule = self.schedule
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update({})
+    if backup_format is not UNSET:
+      field_dict["backup_format"] = backup_format
+    if backup_type is not UNSET:
+      field_dict["backup_type"] = backup_type
+    if retention_days is not UNSET:
+      field_dict["retention_days"] = retention_days
+    if compression is not UNSET:
+      field_dict["compression"] = compression
+    if encryption is not UNSET:
+      field_dict["encryption"] = encryption
+    if schedule is not UNSET:
+      field_dict["schedule"] = schedule
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    backup_format = d.pop("backup_format", UNSET)
+
+    backup_type = d.pop("backup_type", UNSET)
+
+    retention_days = d.pop("retention_days", UNSET)
+
+    compression = d.pop("compression", UNSET)
+
+    encryption = d.pop("encryption", UNSET)
+
+    def _parse_schedule(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)
+
+    schedule = _parse_schedule(d.pop("schedule", UNSET))
+
+    backup_create_request = cls(
+      backup_format=backup_format,
+      backup_type=backup_type,
+      retention_days=retention_days,
+      compression=compression,
+      encryption=encryption,
+      schedule=schedule,
+    )
+
+    backup_create_request.additional_properties = d
+    return backup_create_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/backup_export_request.py

@@ -0,0 +1,72 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BackupExportRequest")
+
+
+@_attrs_define
+class BackupExportRequest:
+  """Request model for exporting a backup.
+
+  Attributes:
+      backup_id (str): ID of backup to export
+      export_format (Union[Unset, str]): Export format - only 'original' is supported (compressed .kuzu file) Default:
+          'original'.
+  """
+
+  backup_id: str
+  export_format: Union[Unset, str] = "original"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    backup_id = self.backup_id
+
+    export_format = self.export_format
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "backup_id": backup_id,
+      }
+    )
+    if export_format is not UNSET:
+      field_dict["export_format"] = export_format
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    backup_id = d.pop("backup_id")
+
+    export_format = d.pop("export_format", UNSET)
+
+    backup_export_request = cls(
+      backup_id=backup_id,
+      export_format=export_format,
+    )
+
+    backup_export_request.additional_properties = d
+    return backup_export_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/backup_list_response.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.backup_response import BackupResponse
+
+
+T = TypeVar("T", bound="BackupListResponse")
+
+
+@_attrs_define
+class BackupListResponse:
+  """Response model for backup list.
+
+  Attributes:
+      backups (list['BackupResponse']):
+      total_count (int):
+      graph_id (str):
+  """
+
+  backups: list["BackupResponse"]
+  total_count: int
+  graph_id: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    backups = []
+    for backups_item_data in self.backups:
+      backups_item = backups_item_data.to_dict()
+      backups.append(backups_item)
+
+    total_count = self.total_count
+
+    graph_id = self.graph_id
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "backups": backups,
+        "total_count": total_count,
+        "graph_id": graph_id,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.backup_response import BackupResponse
+
+    d = dict(src_dict)
+    backups = []
+    _backups = d.pop("backups")
+    for backups_item_data in _backups:
+      backups_item = BackupResponse.from_dict(backups_item_data)
+
+      backups.append(backups_item)
+
+    total_count = d.pop("total_count")
+
+    graph_id = d.pop("graph_id")
+
+    backup_list_response = cls(
+      backups=backups,
+      total_count=total_count,
+      graph_id=graph_id,
+    )
+
+    backup_list_response.additional_properties = d
+    return backup_list_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/backup_response.py

@@ -0,0 +1,200 @@
+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
+
+T = TypeVar("T", bound="BackupResponse")
+
+
+@_attrs_define
+class BackupResponse:
+  """Response model for backup information.
+
+  Attributes:
+      backup_id (str):
+      graph_id (str):
+      backup_format (str):
+      backup_type (str):
+      status (str):
+      original_size_bytes (int):
+      compressed_size_bytes (int):
+      compression_ratio (float):
+      node_count (int):
+      relationship_count (int):
+      backup_duration_seconds (float):
+      encryption_enabled (bool):
+      compression_enabled (bool):
+      allow_export (bool):
+      created_at (str):
+      completed_at (Union[None, str]):
+      expires_at (Union[None, str]):
+  """
+
+  backup_id: str
+  graph_id: str
+  backup_format: str
+  backup_type: str
+  status: str
+  original_size_bytes: int
+  compressed_size_bytes: int
+  compression_ratio: float
+  node_count: int
+  relationship_count: int
+  backup_duration_seconds: float
+  encryption_enabled: bool
+  compression_enabled: bool
+  allow_export: bool
+  created_at: str
+  completed_at: Union[None, str]
+  expires_at: Union[None, str]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    backup_id = self.backup_id
+
+    graph_id = self.graph_id
+
+    backup_format = self.backup_format
+
+    backup_type = self.backup_type
+
+    status = self.status
+
+    original_size_bytes = self.original_size_bytes
+
+    compressed_size_bytes = self.compressed_size_bytes
+
+    compression_ratio = self.compression_ratio
+
+    node_count = self.node_count
+
+    relationship_count = self.relationship_count
+
+    backup_duration_seconds = self.backup_duration_seconds
+
+    encryption_enabled = self.encryption_enabled
+
+    compression_enabled = self.compression_enabled
+
+    allow_export = self.allow_export
+
+    created_at = self.created_at
+
+    completed_at: Union[None, str]
+    completed_at = self.completed_at
+
+    expires_at: Union[None, str]
+    expires_at = self.expires_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "backup_id": backup_id,
+        "graph_id": graph_id,
+        "backup_format": backup_format,
+        "backup_type": backup_type,
+        "status": status,
+        "original_size_bytes": original_size_bytes,
+        "compressed_size_bytes": compressed_size_bytes,
+        "compression_ratio": compression_ratio,
+        "node_count": node_count,
+        "relationship_count": relationship_count,
+        "backup_duration_seconds": backup_duration_seconds,
+        "encryption_enabled": encryption_enabled,
+        "compression_enabled": compression_enabled,
+        "allow_export": allow_export,
+        "created_at": created_at,
+        "completed_at": completed_at,
+        "expires_at": expires_at,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    backup_id = d.pop("backup_id")
+
+    graph_id = d.pop("graph_id")
+
+    backup_format = d.pop("backup_format")
+
+    backup_type = d.pop("backup_type")
+
+    status = d.pop("status")
+
+    original_size_bytes = d.pop("original_size_bytes")
+
+    compressed_size_bytes = d.pop("compressed_size_bytes")
+
+    compression_ratio = d.pop("compression_ratio")
+
+    node_count = d.pop("node_count")
+
+    relationship_count = d.pop("relationship_count")
+
+    backup_duration_seconds = d.pop("backup_duration_seconds")
+
+    encryption_enabled = d.pop("encryption_enabled")
+
+    compression_enabled = d.pop("compression_enabled")
+
+    allow_export = d.pop("allow_export")
+
+    created_at = d.pop("created_at")
+
+    def _parse_completed_at(data: object) -> Union[None, str]:
+      if data is None:
+        return data
+      return cast(Union[None, str], data)
+
+    completed_at = _parse_completed_at(d.pop("completed_at"))
+
+    def _parse_expires_at(data: object) -> Union[None, str]:
+      if data is None:
+        return data
+      return cast(Union[None, str], data)
+
+    expires_at = _parse_expires_at(d.pop("expires_at"))
+
+    backup_response = cls(
+      backup_id=backup_id,
+      graph_id=graph_id,
+      backup_format=backup_format,
+      backup_type=backup_type,
+      status=status,
+      original_size_bytes=original_size_bytes,
+      compressed_size_bytes=compressed_size_bytes,
+      compression_ratio=compression_ratio,
+      node_count=node_count,
+      relationship_count=relationship_count,
+      backup_duration_seconds=backup_duration_seconds,
+      encryption_enabled=encryption_enabled,
+      compression_enabled=compression_enabled,
+      allow_export=allow_export,
+      created_at=created_at,
+      completed_at=completed_at,
+      expires_at=expires_at,
+    )
+
+    backup_response.additional_properties = d
+    return backup_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/backup_restore_request.py

@@ -0,0 +1,81 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BackupRestoreRequest")
+
+
+@_attrs_define
+class BackupRestoreRequest:
+  """Request model for restoring from a backup.
+
+  Attributes:
+      backup_id (str): ID of backup to restore from
+      create_system_backup (Union[Unset, bool]): Create a system backup of existing database before restore Default:
+          True.
+      verify_after_restore (Union[Unset, bool]): Verify database integrity after restore Default: True.
+  """
+
+  backup_id: str
+  create_system_backup: Union[Unset, bool] = True
+  verify_after_restore: Union[Unset, bool] = True
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    backup_id = self.backup_id
+
+    create_system_backup = self.create_system_backup
+
+    verify_after_restore = self.verify_after_restore
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "backup_id": backup_id,
+      }
+    )
+    if create_system_backup is not UNSET:
+      field_dict["create_system_backup"] = create_system_backup
+    if verify_after_restore is not UNSET:
+      field_dict["verify_after_restore"] = verify_after_restore
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    backup_id = d.pop("backup_id")
+
+    create_system_backup = d.pop("create_system_backup", UNSET)
+
+    verify_after_restore = d.pop("verify_after_restore", UNSET)
+
+    backup_restore_request = cls(
+      backup_id=backup_id,
+      create_system_backup=create_system_backup,
+      verify_after_restore=verify_after_restore,
+    )
+
+    backup_restore_request.additional_properties = d
+    return backup_restore_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