robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/schema_export_response.py

@@ -0,0 +1,163 @@
+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.schema_export_response_data_stats_type_0 import (
+    SchemaExportResponseDataStatsType0,
+  )
+  from ..models.schema_export_response_schema_definition_type_0 import (
+    SchemaExportResponseSchemaDefinitionType0,
+  )
+
+
+T = TypeVar("T", bound="SchemaExportResponse")
+
+
+@_attrs_define
+class SchemaExportResponse:
+  """Response model for schema export.
+
+  Attributes:
+      graph_id (str): Graph ID Example: entity_12345.
+      schema_definition (Union['SchemaExportResponseSchemaDefinitionType0', str]): Exported schema definition Example:
+          {'name': 'entity_12345_schema', 'nodes': [{'name': 'Entity', 'properties': []}], 'relationships': [], 'version':
+          '1.0.0'}.
+      format_ (str): Export format used Example: json.
+      exported_at (str): Export timestamp Example: 2024-01-15T10:30:00Z.
+      data_stats (Union['SchemaExportResponseDataStatsType0', None, Unset]): Data statistics if requested Example:
+          {'node_counts': {'Entity': 1, 'Report': 25}, 'total_nodes': 26}.
+  """
+
+  graph_id: str
+  schema_definition: Union["SchemaExportResponseSchemaDefinitionType0", str]
+  format_: str
+  exported_at: str
+  data_stats: Union["SchemaExportResponseDataStatsType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.schema_export_response_data_stats_type_0 import (
+      SchemaExportResponseDataStatsType0,
+    )
+    from ..models.schema_export_response_schema_definition_type_0 import (
+      SchemaExportResponseSchemaDefinitionType0,
+    )
+
+    graph_id = self.graph_id
+
+    schema_definition: Union[dict[str, Any], str]
+    if isinstance(self.schema_definition, SchemaExportResponseSchemaDefinitionType0):
+      schema_definition = self.schema_definition.to_dict()
+    else:
+      schema_definition = self.schema_definition
+
+    format_ = self.format_
+
+    exported_at = self.exported_at
+
+    data_stats: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.data_stats, Unset):
+      data_stats = UNSET
+    elif isinstance(self.data_stats, SchemaExportResponseDataStatsType0):
+      data_stats = self.data_stats.to_dict()
+    else:
+      data_stats = self.data_stats
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "schema_definition": schema_definition,
+        "format": format_,
+        "exported_at": exported_at,
+      }
+    )
+    if data_stats is not UNSET:
+      field_dict["data_stats"] = data_stats
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.schema_export_response_data_stats_type_0 import (
+      SchemaExportResponseDataStatsType0,
+    )
+    from ..models.schema_export_response_schema_definition_type_0 import (
+      SchemaExportResponseSchemaDefinitionType0,
+    )
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    def _parse_schema_definition(
+      data: object,
+    ) -> Union["SchemaExportResponseSchemaDefinitionType0", str]:
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        schema_definition_type_0 = SchemaExportResponseSchemaDefinitionType0.from_dict(
+          data
+        )
+
+        return schema_definition_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SchemaExportResponseSchemaDefinitionType0", str], data)
+
+    schema_definition = _parse_schema_definition(d.pop("schema_definition"))
+
+    format_ = d.pop("format")
+
+    exported_at = d.pop("exported_at")
+
+    def _parse_data_stats(
+      data: object,
+    ) -> Union["SchemaExportResponseDataStatsType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        data_stats_type_0 = SchemaExportResponseDataStatsType0.from_dict(data)
+
+        return data_stats_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SchemaExportResponseDataStatsType0", None, Unset], data)
+
+    data_stats = _parse_data_stats(d.pop("data_stats", UNSET))
+
+    schema_export_response = cls(
+      graph_id=graph_id,
+      schema_definition=schema_definition,
+      format_=format_,
+      exported_at=exported_at,
+      data_stats=data_stats,
+    )
+
+    schema_export_response.additional_properties = d
+    return schema_export_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/schema_export_response_data_stats_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="SchemaExportResponseDataStatsType0")
+
+
+@_attrs_define
+class SchemaExportResponseDataStatsType0:
+  """ """
+
+  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)
+    schema_export_response_data_stats_type_0 = cls()
+
+    schema_export_response_data_stats_type_0.additional_properties = d
+    return schema_export_response_data_stats_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/schema_export_response_schema_definition_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="SchemaExportResponseSchemaDefinitionType0")
+
+
+@_attrs_define
+class SchemaExportResponseSchemaDefinitionType0:
+  """ """
+
+  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)
+    schema_export_response_schema_definition_type_0 = cls()
+
+    schema_export_response_schema_definition_type_0.additional_properties = d
+    return schema_export_response_schema_definition_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/schema_validation_request.py

@@ -0,0 +1,142 @@
+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.schema_validation_request_schema_definition_type_0 import (
+    SchemaValidationRequestSchemaDefinitionType0,
+  )
+
+
+T = TypeVar("T", bound="SchemaValidationRequest")
+
+
+@_attrs_define
+class SchemaValidationRequest:
+  """Request model for schema validation.
+
+  Attributes:
+      schema_definition (Union['SchemaValidationRequestSchemaDefinitionType0', str]): Schema definition as JSON dict
+          or JSON/YAML string Example: {'extends': 'base', 'name': 'inventory_management', 'nodes': [{'name': 'Product',
+          'properties': [{'name': 'sku', 'type': 'STRING', 'is_primary_key': True}, {'name': 'name', 'type': 'STRING',
+          'is_required': True}]}], 'version': '1.0.0'}.
+      format_ (Union[Unset, str]): Schema format: json, yaml, or dict Default: 'json'. Example: json.
+      check_compatibility (Union[None, Unset, list[str]]): List of existing schema extensions to check compatibility
+          with Example: ['roboledger'].
+  """
+
+  schema_definition: Union["SchemaValidationRequestSchemaDefinitionType0", str]
+  format_: Union[Unset, str] = "json"
+  check_compatibility: Union[None, Unset, list[str]] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.schema_validation_request_schema_definition_type_0 import (
+      SchemaValidationRequestSchemaDefinitionType0,
+    )
+
+    schema_definition: Union[dict[str, Any], str]
+    if isinstance(self.schema_definition, SchemaValidationRequestSchemaDefinitionType0):
+      schema_definition = self.schema_definition.to_dict()
+    else:
+      schema_definition = self.schema_definition
+
+    format_ = self.format_
+
+    check_compatibility: Union[None, Unset, list[str]]
+    if isinstance(self.check_compatibility, Unset):
+      check_compatibility = UNSET
+    elif isinstance(self.check_compatibility, list):
+      check_compatibility = self.check_compatibility
+
+    else:
+      check_compatibility = self.check_compatibility
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "schema_definition": schema_definition,
+      }
+    )
+    if format_ is not UNSET:
+      field_dict["format"] = format_
+    if check_compatibility is not UNSET:
+      field_dict["check_compatibility"] = check_compatibility
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.schema_validation_request_schema_definition_type_0 import (
+      SchemaValidationRequestSchemaDefinitionType0,
+    )
+
+    d = dict(src_dict)
+
+    def _parse_schema_definition(
+      data: object,
+    ) -> Union["SchemaValidationRequestSchemaDefinitionType0", str]:
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        schema_definition_type_0 = (
+          SchemaValidationRequestSchemaDefinitionType0.from_dict(data)
+        )
+
+        return schema_definition_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SchemaValidationRequestSchemaDefinitionType0", str], data)
+
+    schema_definition = _parse_schema_definition(d.pop("schema_definition"))
+
+    format_ = d.pop("format", UNSET)
+
+    def _parse_check_compatibility(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()
+        check_compatibility_type_0 = cast(list[str], data)
+
+        return check_compatibility_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[str]], data)
+
+    check_compatibility = _parse_check_compatibility(
+      d.pop("check_compatibility", UNSET)
+    )
+
+    schema_validation_request = cls(
+      schema_definition=schema_definition,
+      format_=format_,
+      check_compatibility=check_compatibility,
+    )
+
+    schema_validation_request.additional_properties = d
+    return schema_validation_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/schema_validation_request_schema_definition_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="SchemaValidationRequestSchemaDefinitionType0")
+
+
+@_attrs_define
+class SchemaValidationRequestSchemaDefinitionType0:
+  """ """
+
+  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)
+    schema_validation_request_schema_definition_type_0 = cls()
+
+    schema_validation_request_schema_definition_type_0.additional_properties = d
+    return schema_validation_request_schema_definition_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/schema_validation_response.py

@@ -0,0 +1,227 @@
+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.schema_validation_response_compatibility_type_0 import (
+    SchemaValidationResponseCompatibilityType0,
+  )
+  from ..models.schema_validation_response_stats_type_0 import (
+    SchemaValidationResponseStatsType0,
+  )
+
+
+T = TypeVar("T", bound="SchemaValidationResponse")
+
+
+@_attrs_define
+class SchemaValidationResponse:
+  """Response model for schema validation.
+
+  Attributes:
+      valid (bool): Whether the schema is valid Example: True.
+      message (str): Validation message Example: Schema is valid with 1 warning(s).
+      errors (Union[None, Unset, list[str]]): List of validation errors
+      warnings (Union[None, Unset, list[str]]): List of warnings Example: ['Schema has no relationships defined'].
+      stats (Union['SchemaValidationResponseStatsType0', None, Unset]): Schema statistics (nodes, relationships,
+          properties) Example: {'nodes': 2, 'primary_keys': 2, 'relationships': 1, 'total_properties': 6}.
+      compatibility (Union['SchemaValidationResponseCompatibilityType0', None, Unset]): Compatibility check results if
+          requested Example: {'checked_extensions': ['roboledger'], 'compatible': True, 'conflicts': []}.
+  """
+
+  valid: bool
+  message: str
+  errors: Union[None, Unset, list[str]] = UNSET
+  warnings: Union[None, Unset, list[str]] = UNSET
+  stats: Union["SchemaValidationResponseStatsType0", None, Unset] = UNSET
+  compatibility: Union["SchemaValidationResponseCompatibilityType0", None, Unset] = (
+    UNSET
+  )
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.schema_validation_response_compatibility_type_0 import (
+      SchemaValidationResponseCompatibilityType0,
+    )
+    from ..models.schema_validation_response_stats_type_0 import (
+      SchemaValidationResponseStatsType0,
+    )
+
+    valid = self.valid
+
+    message = self.message
+
+    errors: Union[None, Unset, list[str]]
+    if isinstance(self.errors, Unset):
+      errors = UNSET
+    elif isinstance(self.errors, list):
+      errors = self.errors
+
+    else:
+      errors = self.errors
+
+    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
+
+    stats: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.stats, Unset):
+      stats = UNSET
+    elif isinstance(self.stats, SchemaValidationResponseStatsType0):
+      stats = self.stats.to_dict()
+    else:
+      stats = self.stats
+
+    compatibility: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.compatibility, Unset):
+      compatibility = UNSET
+    elif isinstance(self.compatibility, SchemaValidationResponseCompatibilityType0):
+      compatibility = self.compatibility.to_dict()
+    else:
+      compatibility = self.compatibility
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "valid": valid,
+        "message": message,
+      }
+    )
+    if errors is not UNSET:
+      field_dict["errors"] = errors
+    if warnings is not UNSET:
+      field_dict["warnings"] = warnings
+    if stats is not UNSET:
+      field_dict["stats"] = stats
+    if compatibility is not UNSET:
+      field_dict["compatibility"] = compatibility
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.schema_validation_response_compatibility_type_0 import (
+      SchemaValidationResponseCompatibilityType0,
+    )
+    from ..models.schema_validation_response_stats_type_0 import (
+      SchemaValidationResponseStatsType0,
+    )
+
+    d = dict(src_dict)
+    valid = d.pop("valid")
+
+    message = d.pop("message")
+
+    def _parse_errors(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()
+        errors_type_0 = cast(list[str], data)
+
+        return errors_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[str]], data)
+
+    errors = _parse_errors(d.pop("errors", 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_stats(
+      data: object,
+    ) -> Union["SchemaValidationResponseStatsType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        stats_type_0 = SchemaValidationResponseStatsType0.from_dict(data)
+
+        return stats_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SchemaValidationResponseStatsType0", None, Unset], data)
+
+    stats = _parse_stats(d.pop("stats", UNSET))
+
+    def _parse_compatibility(
+      data: object,
+    ) -> Union["SchemaValidationResponseCompatibilityType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        compatibility_type_0 = SchemaValidationResponseCompatibilityType0.from_dict(
+          data
+        )
+
+        return compatibility_type_0
+      except:  # noqa: E722
+        pass
+      return cast(
+        Union["SchemaValidationResponseCompatibilityType0", None, Unset], data
+      )
+
+    compatibility = _parse_compatibility(d.pop("compatibility", UNSET))
+
+    schema_validation_response = cls(
+      valid=valid,
+      message=message,
+      errors=errors,
+      warnings=warnings,
+      stats=stats,
+      compatibility=compatibility,
+    )
+
+    schema_validation_response.additional_properties = d
+    return schema_validation_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