amsdal 0.4.13__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

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,125 @@
+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):
+                    if _dependency not in _defined_schemas:
+                        exc_msg = f'Class {_dependency} ({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: ...

amsdal/schemas/repository.py

@@ -0,0 +1,84 @@
+from amsdal_utils.models.enums import ModuleType
+from amsdal_utils.schemas.interfaces import BaseDependsSchemaLoader
+from amsdal_utils.schemas.interfaces import BaseSchemaLoader
+from amsdal_utils.schemas.schema import ObjectSchema
+
+from amsdal.schemas.mixins.check_dependencies_mixin import CheckDependenciesMixin
+from amsdal.schemas.mixins.verify_schemas_mixin import VerifySchemasMixin
+from amsdal.schemas.utils import ModelModuleInfo
+
+
+class SchemaRepository(VerifySchemasMixin, CheckDependenciesMixin):
+    type_schemas: list[ObjectSchema]
+    core_schemas: list[ObjectSchema]
+    contrib_schemas: list[ObjectSchema]
+    user_schemas: list[ObjectSchema]
+
+    def __init__(
+        self,
+        type_schema_loader: BaseSchemaLoader,
+        core_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+        contrib_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+        user_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+    ):
+        self._type_schema_loader = type_schema_loader
+        self._core_schema_loader = core_schema_loader
+        self._contrib_schema_loader = contrib_schema_loader
+        self._user_schema_loader = user_schema_loader
+
+        self.type_schemas = type_schema_loader.load()
+        self.core_schemas = self._load_schemas(core_schema_loader)
+        self.contrib_schemas = self._load_schemas(contrib_schema_loader, self.core_schemas)
+        self.user_schemas = self._load_schemas(user_schema_loader, self.core_schemas, self.contrib_schemas)
+
+        self.verify_schemas(
+            self.type_schemas,
+            self.core_schemas,
+            self.contrib_schemas,
+            self.user_schemas,
+        )
+        self.check_dependencies(
+            self.type_schemas,
+            self.core_schemas,
+            self.contrib_schemas,
+            self.user_schemas,
+        )
+
+    @property
+    def model_module_info(self) -> ModelModuleInfo:
+        _type_info = self._prepare_info(self._type_schema_loader.schemas_per_module)
+        _core_info = self._prepare_info(self._core_schema_loader.schemas_per_module)
+        _contrib_info = self._prepare_info(self._contrib_schema_loader.schemas_per_module)
+        _user_info = self._prepare_info(self._user_schema_loader.schemas_per_module)
+
+        return ModelModuleInfo(
+            info={
+                ModuleType.TYPE: _type_info,
+                ModuleType.CORE: _core_info,
+                ModuleType.CONTRIB: _contrib_info,
+                ModuleType.USER: _user_info,
+            },
+        )
+
+    def _load_schemas(
+        self,
+        loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+        *extra_schemas: list[ObjectSchema],
+    ) -> list[ObjectSchema]:
+
+        if isinstance(loader, BaseDependsSchemaLoader):
+            return loader.load(self.type_schemas, *extra_schemas)
+        else:
+            _schemas, _circular = loader.load_sorted()
+            return _schemas + _circular
+
+    @staticmethod
+    def _prepare_info(schemas_per_module: dict[str, list[ObjectSchema]]) -> dict[str, str]:
+        _info = {}
+
+        for module_path, schemas in schemas_per_module.items():
+            _info.update(
+                {_schema.title: module_path for _schema in schemas},
+            )
+
+        return _info

amsdal/schemas/repository.pyi

@@ -0,0 +1,22 @@
+from _typeshed import Incomplete
+from amsdal.schemas.mixins.check_dependencies_mixin import CheckDependenciesMixin as CheckDependenciesMixin
+from amsdal.schemas.mixins.verify_schemas_mixin import VerifySchemasMixin as VerifySchemasMixin
+from amsdal.schemas.utils import ModelModuleInfo as ModelModuleInfo
+from amsdal_utils.schemas.interfaces import BaseDependsSchemaLoader, BaseSchemaLoader as BaseSchemaLoader
+from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
+
+class SchemaRepository(VerifySchemasMixin, CheckDependenciesMixin):
+    type_schemas: list[ObjectSchema]
+    core_schemas: list[ObjectSchema]
+    contrib_schemas: list[ObjectSchema]
+    user_schemas: list[ObjectSchema]
+    _type_schema_loader: Incomplete
+    _core_schema_loader: Incomplete
+    _contrib_schema_loader: Incomplete
+    _user_schema_loader: Incomplete
+    def __init__(self, type_schema_loader: BaseSchemaLoader, core_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader, contrib_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader, user_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader) -> None: ...
+    @property
+    def model_module_info(self) -> ModelModuleInfo: ...
+    def _load_schemas(self, loader: BaseSchemaLoader | BaseDependsSchemaLoader, *extra_schemas: list[ObjectSchema]) -> list[ObjectSchema]: ...
+    @staticmethod
+    def _prepare_info(schemas_per_module: dict[str, list[ObjectSchema]]) -> dict[str, str]: ...

amsdal/schemas/types/anything/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Anything",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/array/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Array",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/binary/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Binary",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/boolean/model.json

@@ -0,0 +1,17 @@
+{
+  "title": "Boolean",
+  "type": "object",
+  "options": [
+    {
+      "key": "true",
+      "value": true
+    },
+    {
+      "key": "false",
+      "value": false
+    }
+  ],
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/date/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Date",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/datetime/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Datetime",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/dictionary/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "Dictionary",
+  "type": "object",
+  "default": null,
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/number/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "Number",
+  "type": "object",
+  "default": null,
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/object/model.json

@@ -0,0 +1,53 @@
+{
+  "title": "Object",
+  "type": "object",
+  "default": null,
+  "properties": {
+    "title": {
+      "title": "Title",
+      "type": "string"
+    },
+    "type": {
+      "title": "Type",
+      "type": "string"
+    },
+    "default": {
+      "title": "Default",
+      "type": "anything"
+    },
+    "properties": {
+      "title": "Properties",
+      "type": "dictionary",
+      "items": {
+        "key": {"type": "string"},
+        "value": {"type": "anything"}
+      }
+    },
+    "required": {
+      "title": "Required",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "unique": {
+      "title": "Unique Fields",
+      "type": "array",
+      "items": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "custom_code": {
+      "title": "Custom Code",
+      "type": "string"
+    },
+    "meta_class": {
+      "title": "Meta Class",
+      "type": "string"
+    }
+  },
+  "required": []
+}

amsdal/schemas/types/string/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "String",
+  "type": "object",
+  "default": "",
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/utils.py

@@ -0,0 +1,16 @@
+from typing import TypeAlias
+
+from amsdal_utils.models.enums import ModuleType
+
+ModulePathType: TypeAlias = str
+ClassNameType: TypeAlias = str
+
+
+class ModelModuleInfo:
+    _info: dict[ModuleType, dict[ClassNameType, ModulePathType]]
+
+    def __init__(self, info: dict[ModuleType, dict[ClassNameType, ModulePathType]]) -> None:
+        self._info = info
+
+    def get_by_type(self, module_type: ModuleType) -> dict[ClassNameType, ModulePathType]:
+        return self._info.get(module_type, {})

amsdal/schemas/utils.pyi

@@ -0,0 +1,10 @@
+from amsdal_utils.models.enums import ModuleType as ModuleType
+from typing import TypeAlias
+
+ModulePathType: TypeAlias = str
+ClassNameType: TypeAlias = str
+
+class ModelModuleInfo:
+    _info: dict[ModuleType, dict[ClassNameType, ModulePathType]]
+    def __init__(self, info: dict[ModuleType, dict[ClassNameType, ModulePathType]]) -> None: ...
+    def get_by_type(self, module_type: ModuleType) -> dict[ClassNameType, ModulePathType]: ...