amsdal 0.5.23__cp311-cp311-macosx_10_9_universal2.whl

amsdal/schemas/core/file/model.json

@@ -0,0 +1,23 @@
+{
+  "title": "File",
+  "type": "object",
+  "default": null,
+  "properties": {
+    "filename": {
+      "title": "Filename",
+      "type": "string"
+    },
+    "data": {
+      "title": "Data",
+      "type": "binary"
+    },
+    "size": {
+      "title": "Size",
+      "type": "number"
+    }
+  },
+  "required": [
+    "filename",
+    "data"
+  ]
+}

amsdal/schemas/core/file/properties/from_file.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import BinaryIO
+
+
+@classmethod  # type: ignore[misc, no-untyped-def]
+def from_file(  # type: ignore[no-untyped-def]
+    cls,
+    file_or_path: Path | BinaryIO,
+) -> 'File':  # type: ignore[name-defined]  # noqa: F821
+    """
+    Creates a `File` object from a file path or a binary file object.
+
+    Args:
+        file_or_path (Path | BinaryIO): The file path or binary file object.
+
+    Returns:
+        File: The created `File` object.
+
+    Raises:
+        ValueError: If the provided path is a directory.
+    """
+    if isinstance(file_or_path, Path):
+        if file_or_path.is_dir():
+            msg = f'{file_or_path} is a directory'
+            raise ValueError(msg)
+
+        data = file_or_path.read_bytes()
+        filename = file_or_path.name
+    else:
+        file_or_path.seek(0)
+        data = file_or_path.read()
+        filename = Path(file_or_path.name).name
+
+    return cls(data=data, filename=filename)

amsdal/schemas/core/file/properties/mimetype.py

@@ -0,0 +1,13 @@
+@property  # type: ignore[misc]
+def mimetype(self) -> str | None:  # type: ignore[no-untyped-def]
+    """
+    Returns the MIME type of the file based on its filename.
+
+    This method uses the `mimetypes` module to guess the MIME type of the file.
+
+    Returns:
+        str | None: The guessed MIME type of the file, or None if it cannot be determined.
+    """
+    import mimetypes
+
+    return mimetypes.guess_type(self.filename)[0]

amsdal/schemas/core/file/properties/str.py

@@ -0,0 +1,6 @@
+def __str__(self) -> str:  # type: ignore[no-untyped-def] # noqa: N807
+    return repr(self)
+
+
+def __repr__(self) -> str:  # type: ignore[no-untyped-def] # noqa: N807
+    return f'File<{self.filename}>({self.size or len(self.data) or 0} bytes)'

amsdal/schemas/core/file/properties/to_file.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import BinaryIO
+
+
+def to_file(self, file_or_path: Path | BinaryIO) -> None:  # type: ignore[no-untyped-def]
+    """
+    Writes the object's data to a file path or a binary file object.
+
+    Args:
+        file_or_path (Path | BinaryIO): The file path or binary file object where the data will be written.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the provided path is a directory.
+    """
+    if isinstance(file_or_path, Path):
+        if file_or_path.is_dir():
+            file_or_path = file_or_path / self.name
+        file_or_path.write_bytes(self.data)  # type: ignore[union-attr]
+    else:
+        file_or_path.write(self.data)
+        file_or_path.seek(0)

amsdal/schemas/core/file/properties/validate_data.py

@@ -0,0 +1,31 @@
+import base64
+from contextlib import suppress
+
+from pydantic import field_validator
+
+
+@field_validator('data')  # type: ignore[misc]
+@classmethod
+def data_base64_decode(cls, v: bytes) -> bytes:  # type: ignore[no-untyped-def]
+    """
+    Decodes a base64-encoded byte string if it is base64-encoded.
+
+    This method checks if the provided byte string is base64-encoded and decodes it if true.
+    If the byte string is not base64-encoded, it returns the original byte string.
+
+    Args:
+        cls: The class this method belongs to.
+        v (bytes): The byte string to be checked and potentially decoded.
+
+    Returns:
+        bytes: The decoded byte string if it was base64-encoded, otherwise the original byte string.
+    """
+    is_base64: bool = False
+
+    with suppress(Exception):
+        is_base64 = base64.b64encode(base64.b64decode(v)) == v
+
+    if is_base64:
+        return base64.b64decode(v)
+
+    return v

amsdal/schemas/core/fixture/model.json

@@ -0,0 +1,35 @@
+{
+  "title": "Fixture",
+  "type": "object",
+  "properties": {
+    "class_name": {
+      "title": "Class Name",
+      "type": "string"
+    },
+    "order": {
+      "title": "Order",
+      "type": "number"
+    },
+    "external_id": {
+      "title": "External ID",
+      "type": "string"
+    },
+    "data": {
+      "title": "Data",
+      "type": "dictionary",
+      "items": {
+        "key": {"type": "string"},
+        "value": {"type": "anything"}
+      }
+    }
+  },
+  "required": [
+    "data",
+    "external_id"
+  ],
+  "unique": [
+    [
+      "external_id"
+    ]
+  ]
+}

amsdal/schemas/core/option/model.json

@@ -0,0 +1,19 @@
+{
+  "title": "Option",
+  "type": "object",
+  "properties": {
+    "key": {
+      "title": "Key",
+      "type": "string"
+    },
+    "value": {
+      "title": "Value Type",
+      "type": "string"
+    }
+  },
+  "required": [
+    "key",
+    "value"
+  ],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/core/storage_metadata/model.json

@@ -0,0 +1,52 @@
+{
+  "title": "StorageMetadata",
+  "type": "object",
+  "properties": {
+    "table_name": {
+      "title": "Table name",
+      "type": "string"
+    },
+    "db_fields": {
+      "title": "Database fields",
+      "type": "dictionary",
+      "items": {
+        "key": {"type": "string"},
+        "value": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "primary_key": {
+      "title": "Primary key fields",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "indexed": {
+      "title": "Indexed",
+      "type": "array",
+      "items": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "unique": {
+      "title": "Unique Fields",
+      "type": "array",
+      "items": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/core/validator/model.json

@@ -0,0 +1,19 @@
+{
+  "title": "Validator",
+  "type": "object",
+  "properties": {
+    "name": {
+      "title": "Validator Name",
+      "type": "string"
+    },
+    "data": {
+      "title": "Validator Data",
+      "type": "anything"
+    }
+  },
+  "required": [
+    "name",
+    "data"
+  ],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/interfaces.py

@@ -0,0 +1,25 @@
+from abc import ABC
+from abc import abstractmethod
+from typing import TypeAlias
+
+from amsdal_utils.schemas.schema import ObjectSchema
+
+ModulePathType: TypeAlias = str
+
+
+class BaseSchemaLoader(ABC):
+    @property
+    @abstractmethod
+    def schemas_per_module(self) -> dict[ModulePathType, list[ObjectSchema]]: ...
+
+    @abstractmethod
+    def load(self) -> list[ObjectSchema]: ...
+
+
+class BaseDependsSchemaLoader(ABC):
+    @property
+    @abstractmethod
+    def schemas_per_module(self) -> dict[ModulePathType, list[ObjectSchema]]: ...
+
+    @abstractmethod
+    def load(self, type_schemas: list[ObjectSchema], *extra_schemas: list[ObjectSchema]) -> list[ObjectSchema]: ...

amsdal/schemas/interfaces.pyi

@@ -0,0 +1,20 @@
+import abc
+from abc import ABC, abstractmethod
+from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
+from typing import TypeAlias
+
+ModulePathType: TypeAlias = str
+
+class BaseSchemaLoader(ABC, metaclass=abc.ABCMeta):
+    @property
+    @abstractmethod
+    def schemas_per_module(self) -> dict[ModulePathType, list[ObjectSchema]]: ...
+    @abstractmethod
+    def load(self) -> list[ObjectSchema]: ...
+
+class BaseDependsSchemaLoader(ABC, metaclass=abc.ABCMeta):
+    @property
+    @abstractmethod
+    def schemas_per_module(self) -> dict[ModulePathType, list[ObjectSchema]]: ...
+    @abstractmethod
+    def load(self, type_schemas: list[ObjectSchema], *extra_schemas: list[ObjectSchema]) -> list[ObjectSchema]: ...

amsdal/schemas/mixins/check_dependencies_mixin.py

@@ -0,0 +1,130 @@
+from amsdal_models.errors import AmsdalValidationError
+from amsdal_utils.models.data_models.core import DictSchema
+from amsdal_utils.models.data_models.core import LegacyDictSchema
+from amsdal_utils.models.data_models.core import TypeData
+from amsdal_utils.models.data_models.enums import CoreTypes
+from amsdal_utils.schemas.schema import ObjectSchema
+
+
+class CheckDependenciesMixin:
+    """
+    Mixin class to check dependencies among schemas.
+
+    This class provides methods to check if all dependencies for a given set of schemas are defined. It raises an
+    `AmsdalValidationError` if any dependency is not defined.
+    """
+
+    def check_dependencies(
+        self,
+        type_schemas: list[ObjectSchema],
+        core_schemas: list[ObjectSchema],
+        contrib_schemas: list[ObjectSchema],
+        user_schemas: list[ObjectSchema],
+    ) -> None:
+        """
+        Checks if all dependencies for the given schemas are defined.
+
+        This method verifies that all dependencies for the provided type, core, contrib, and user schemas are defined.
+        If any dependency is not defined, it raises an `AmsdalValidationError`.
+
+        Args:
+            type_schemas (list[ObjectSchema]): A list of type schemas to check.
+            core_schemas (list[ObjectSchema]): A list of core schemas to check.
+            contrib_schemas (list[ObjectSchema]): A list of contrib schemas to check.
+            user_schemas (list[ObjectSchema]): A list of user schemas to check.
+
+        Raises:
+            AmsdalValidationError: If any dependency is not defined.
+
+        Returns:
+            None
+        """
+        _defined_schemas: set[str] = {
+            *[schema.title.lower() for schema in type_schemas],
+            *[schema.title for schema in core_schemas],
+            *[schema.title for schema in contrib_schemas],
+            *[schema.title for schema in user_schemas],
+        }
+        _defined_schemas.update(
+            {
+                CoreTypes.NUMBER,
+                CoreTypes.INTEGER,
+                CoreTypes.STRING,
+                CoreTypes.BOOLEAN,
+                CoreTypes.DICTIONARY,
+                CoreTypes.ARRAY,
+                CoreTypes.ANYTHING,
+                CoreTypes.BINARY,
+                CoreTypes.OBJECT,
+                CoreTypes.DATETIME,
+                CoreTypes.DATE,
+            }
+        )
+        all_schemas: list[ObjectSchema] = []
+        all_schemas.extend(type_schemas)
+        all_schemas.extend(core_schemas)
+        all_schemas.extend(contrib_schemas)
+        all_schemas.extend(user_schemas)
+
+        for source, schemas in (
+            ('type_schemas', type_schemas),
+            ('core_schemas', core_schemas),
+            ('contrib_schemas', contrib_schemas),
+            ('user_schemas', user_schemas),
+        ):
+            for _schema in schemas:
+                for _dependency in self.get_dependency_type_names(_schema):
+                    _dependencies = [_dependency]
+                    if '|' in _dependency:
+                        _dependencies = [dep.strip() for dep in _dependency.split('|')]
+
+                    for _d in _dependencies:
+                        if _d not in _defined_schemas:
+                            exc_msg = f'Class {_d} ({source}) is undefined! This class is set as dependency for {_schema.title}'  # noqa: E501
+                            raise AmsdalValidationError(exc_msg)
+
+    @classmethod
+    def get_dependency_type_names(cls, schema: ObjectSchema) -> set[str]:
+        """
+        Returns a set of dependency type names for the given schema.
+
+        This method extracts and returns a set of type names that the given schema depends on. It includes the schema's
+        own type, the types of its properties, and the types of items within array or dictionary properties.
+
+        Args:
+            schema (ObjectSchema): The schema for which to get dependency type names.
+
+        Returns:
+            set[str]: A set of dependency type names for the given schema.
+        """
+        _dependencies: set[str] = {
+            schema.type,
+        }
+
+        for _property in schema.properties.values() if schema.properties else []:
+            if cls._is_enum(_property):
+                continue
+
+            _dependencies.add(_property.type)
+
+            if _property.type == CoreTypes.ARRAY and isinstance(_property.items, TypeData):
+                if not cls._is_enum(_property.items):
+                    _dependencies.add(_property.items.type)
+            elif _property.type == CoreTypes.DICTIONARY:
+                if isinstance(_property.items, LegacyDictSchema):
+                    _dependencies.add(_property.items.key_type)
+                    _dependencies.add(_property.items.value_type)
+                elif isinstance(_property.items, DictSchema):
+                    if not cls._is_enum(_property.items.key):
+                        _dependencies.add(_property.items.key.type)
+                    if not cls._is_enum(_property.items.value):
+                        _dependencies.add(_property.items.value.type)
+
+        # remove self reference
+        _dependencies.discard(schema.title)
+
+        return _dependencies
+
+    @classmethod
+    def _is_enum(cls, _type: TypeData) -> bool:
+        return bool(hasattr(_type, 'enum') and _type.enum and _type.options)

amsdal/schemas/mixins/check_dependencies_mixin.pyi

@@ -0,0 +1,45 @@
+from amsdal_utils.models.data_models.core import TypeData
+from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
+
+class CheckDependenciesMixin:
+    """
+    Mixin class to check dependencies among schemas.
+
+    This class provides methods to check if all dependencies for a given set of schemas are defined. It raises an
+    `AmsdalValidationError` if any dependency is not defined.
+    """
+    def check_dependencies(self, type_schemas: list[ObjectSchema], core_schemas: list[ObjectSchema], contrib_schemas: list[ObjectSchema], user_schemas: list[ObjectSchema]) -> None:
+        """
+        Checks if all dependencies for the given schemas are defined.
+
+        This method verifies that all dependencies for the provided type, core, contrib, and user schemas are defined.
+        If any dependency is not defined, it raises an `AmsdalValidationError`.
+
+        Args:
+            type_schemas (list[ObjectSchema]): A list of type schemas to check.
+            core_schemas (list[ObjectSchema]): A list of core schemas to check.
+            contrib_schemas (list[ObjectSchema]): A list of contrib schemas to check.
+            user_schemas (list[ObjectSchema]): A list of user schemas to check.
+
+        Raises:
+            AmsdalValidationError: If any dependency is not defined.
+
+        Returns:
+            None
+        """
+    @classmethod
+    def get_dependency_type_names(cls, schema: ObjectSchema) -> set[str]:
+        """
+        Returns a set of dependency type names for the given schema.
+
+        This method extracts and returns a set of type names that the given schema depends on. It includes the schema's
+        own type, the types of its properties, and the types of items within array or dictionary properties.
+
+        Args:
+            schema (ObjectSchema): The schema for which to get dependency type names.
+
+        Returns:
+            set[str]: A set of dependency type names for the given schema.
+        """
+    @classmethod
+    def _is_enum(cls, _type: TypeData) -> bool: ...

amsdal/schemas/mixins/verify_schemas_mixin.py

@@ -0,0 +1,96 @@
+from amsdal_models.errors import AmsdalValidationError
+from amsdal_utils.schemas.schema import ObjectSchema
+
+
+class VerifySchemasMixin:
+    """
+    Mixin class to verify schemas for uniqueness and property consistency.
+
+    This class provides methods to verify that schemas are unique and that their properties are consistent. It raises
+    an `AmsdalValidationError` if any schema is duplicated or if any required or unique property is missing.
+    """
+
+    def verify_schemas(
+        self,
+        type_schemas: list[ObjectSchema],
+        core_schemas: list[ObjectSchema],
+        contrib_schemas: list[ObjectSchema],
+        user_schemas: list[ObjectSchema],
+    ) -> None:
+        """
+        Verifies the provided schemas for uniqueness and property consistency.
+
+        This method checks that the provided type, core, contrib, and user schemas are unique and that their properties
+        are consistent. It raises an `AmsdalValidationError` if any schema is duplicated or if any required or unique
+        property is missing.
+
+        Args:
+            type_schemas (list[ObjectSchema]): A list of type schemas to verify.
+            core_schemas (list[ObjectSchema]): A list of core schemas to verify.
+            contrib_schemas (list[ObjectSchema]): A list of contrib schemas to verify.
+            user_schemas (list[ObjectSchema]): A list of user schemas to verify.
+
+        Raises:
+            AmsdalValidationError: If any schema is duplicated or if any required or unique property is missing.
+
+        Returns:
+            None
+        """
+        self._verify_unique_schemas(type_schemas, core_schemas, contrib_schemas, user_schemas)
+        self._verify_properties(type_schemas, core_schemas, contrib_schemas, user_schemas)
+
+    @staticmethod
+    def _verify_unique_schemas(
+        type_schemas: list[ObjectSchema],
+        core_schemas: list[ObjectSchema],
+        contrib_schemas: list[ObjectSchema],
+        user_schemas: list[ObjectSchema],
+    ) -> None:
+        _unique_schemas: dict[str, str] = {}
+
+        for source, schemas in (
+            ('type_schemas', type_schemas),
+            ('core_schemas', core_schemas),
+            ('contrib_schemas', contrib_schemas),
+            ('user_schemas', user_schemas),
+        ):
+            for _schema in schemas:
+                if _schema.title in _unique_schemas:
+                    msg = f"Schema '{source}'.'{_schema.title}' is duplicated (already registered in {_unique_schemas[_schema.title]})."  # noqa: E501
+                    raise AmsdalValidationError(msg)
+
+                _unique_schemas[_schema.title] = source
+
+    @staticmethod
+    def _verify_properties(
+        type_schemas: list[ObjectSchema],
+        core_schemas: list[ObjectSchema],
+        contrib_schemas: list[ObjectSchema],
+        user_schemas: list[ObjectSchema],
+    ) -> None:
+        all_schemas: list[ObjectSchema] = []
+        all_schemas.extend(type_schemas)
+        all_schemas.extend(core_schemas)
+        all_schemas.extend(contrib_schemas)
+        all_schemas.extend(user_schemas)
+
+        for _schema in all_schemas:
+            for _field in ['required', 'indexed']:
+                for _required_property in getattr(_schema, _field, None) or []:
+                    if _required_property not in (_schema.properties or {}):
+                        exc_msg = (
+                            f'Property {_required_property} marked as {_field} '
+                            f"but wasn't found in class schema's properties."
+                        )
+
+                        raise AmsdalValidationError(exc_msg)
+
+            for unique in getattr(_schema, 'unique', None) or []:
+                for unique_property in unique:
+                    if unique_property not in (_schema.properties or {}):
+                        exc_msg = (
+                            f"Property {unique_property} marked is used in 'unique' "
+                            f"but wasn't found in class schema's properties."
+                        )
+
+                        raise AmsdalValidationError(exc_msg)

amsdal/schemas/mixins/verify_schemas_mixin.pyi

@@ -0,0 +1,33 @@
+from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
+
+class VerifySchemasMixin:
+    """
+    Mixin class to verify schemas for uniqueness and property consistency.
+
+    This class provides methods to verify that schemas are unique and that their properties are consistent. It raises
+    an `AmsdalValidationError` if any schema is duplicated or if any required or unique property is missing.
+    """
+    def verify_schemas(self, type_schemas: list[ObjectSchema], core_schemas: list[ObjectSchema], contrib_schemas: list[ObjectSchema], user_schemas: list[ObjectSchema]) -> None:
+        """
+        Verifies the provided schemas for uniqueness and property consistency.
+
+        This method checks that the provided type, core, contrib, and user schemas are unique and that their properties
+        are consistent. It raises an `AmsdalValidationError` if any schema is duplicated or if any required or unique
+        property is missing.
+
+        Args:
+            type_schemas (list[ObjectSchema]): A list of type schemas to verify.
+            core_schemas (list[ObjectSchema]): A list of core schemas to verify.
+            contrib_schemas (list[ObjectSchema]): A list of contrib schemas to verify.
+            user_schemas (list[ObjectSchema]): A list of user schemas to verify.
+
+        Raises:
+            AmsdalValidationError: If any schema is duplicated or if any required or unique property is missing.
+
+        Returns:
+            None
+        """
+    @staticmethod
+    def _verify_unique_schemas(type_schemas: list[ObjectSchema], core_schemas: list[ObjectSchema], contrib_schemas: list[ObjectSchema], user_schemas: list[ObjectSchema]) -> None: ...
+    @staticmethod
+    def _verify_properties(type_schemas: list[ObjectSchema], core_schemas: list[ObjectSchema], contrib_schemas: list[ObjectSchema], user_schemas: list[ObjectSchema]) -> None: ...