amsdal 0.3.3__cp311-cp311-macosx_10_9_universal2.whl → 0.5.29__cp311-cp311-macosx_10_9_universal2.whl

amsdal/schemas/manager.py

@@ -1,116 +0,0 @@
-from amsdal_models.schemas.manager import SchemaManagerHandler
-from amsdal_utils.models.data_models.enums import BaseClasses
-from amsdal_utils.models.data_models.schema import ObjectSchema
-from amsdal_utils.models.enums import SchemaTypes
-from amsdal_utils.utils.singleton import Singleton
-
-from amsdal.configs.main import settings
-
-
-class SchemaManager(metaclass=Singleton):
-    """
-    Manages schema operations including retrieval, invalidation, and sorting.
-
-    This class handles various schema-related operations such as invalidating user schemas,
-    retrieving schemas by name or type, and sorting schemas based on predefined rules.
-    """
-
-    def __init__(self) -> None:
-        self._schema_manager_handler = SchemaManagerHandler(settings.schemas_root_path)
-
-    def invalidate_user_schemas(self) -> None:
-        """
-        Invalidates user schemas.
-
-        This method calls the handler to invalidate all user schemas, ensuring that any cached or outdated schemas
-            are refreshed.
-
-        Returns:
-            None
-        """
-        self._schema_manager_handler.invalidate_user_schemas()
-
-    def class_schemas(self) -> list[tuple[ObjectSchema, SchemaTypes]]:
-        """
-        Returns a list of tuples containing object schemas and their types.
-
-        This method retrieves and sorts various schemas managed by the schema manager handler.
-        The schemas are categorized into types, core, user, and contrib schemas.
-
-        Returns:
-            list[tuple[ObjectSchema, SchemaTypes]]: A list of tuples where each tuple contains an object schema
-                and its corresponding type.
-        """
-        return (
-            [
-                (type_schema, SchemaTypes.TYPE)
-                for type_schema in self._schema_manager_handler.type_schemas
-                if type_schema.title == BaseClasses.OBJECT
-            ]
-            + [
-                (core_schema, SchemaTypes.CORE)
-                for core_schema in sorted(self._schema_manager_handler.core_schemas, key=self._sort_key_for_schema)
-            ]
-            + [(user_schema, SchemaTypes.USER) for user_schema in self._schema_manager_handler.user_schemas]
-            + [(contrib_schema, SchemaTypes.CONTRIB) for contrib_schema in self._schema_manager_handler.contrib_schemas]
-        )
-
-    @staticmethod
-    def _sort_key_for_schema(schema: ObjectSchema) -> int:
-        # We need to register ClassObject first, coz ClassObjectMeta has a reference to it.
-        # All other classes have reference to ClassObject
-        if schema.title == BaseClasses.CLASS_OBJECT:
-            return 0
-        elif schema.title == BaseClasses.CLASS_OBJECT_META:
-            return 1
-        else:
-            return 2
-
-    def get_schema_by_name(self, title: str, schema_type: SchemaTypes | None = None) -> ObjectSchema | None:
-        """
-        Retrieves a schema by its title and optional type.
-
-        This method searches for a schema with the specified title and optional type
-        among the schemas managed by the schema manager handler.
-
-        Args:
-            title (str): The title of the schema to be retrieved.
-            schema_type (SchemaTypes | None, optional): The type of the schema to be retrieved. Defaults to None.
-
-        Returns:
-            ObjectSchema | None: The schema with the specified title and type, or None if not found.
-        """
-        _schemas = self.get_schemas(schema_type)
-
-        for schema in _schemas:
-            if schema.title == title:
-                return schema
-
-        return None
-
-    def get_schemas(self, schema_type: SchemaTypes | None = None) -> list[ObjectSchema]:
-        """
-        Retrieves schemas based on the provided type.
-
-        This method returns a list of schemas filtered by the specified type. If no type is provided,
-        it returns all schemas managed by the schema manager handler.
-
-        Args:
-            schema_type (SchemaTypes | None, optional): The type of schemas to retrieve. Defaults to None.
-
-        Returns:
-            list[ObjectSchema]: A list of schemas filtered by the specified type, or all schemas if no type is provided.
-        """
-        if schema_type == SchemaTypes.CONTRIB:
-            return self._schema_manager_handler.contrib_schemas
-
-        if schema_type == SchemaTypes.CORE:
-            return self._schema_manager_handler.core_schemas
-
-        if schema_type == SchemaTypes.TYPE:
-            return self._schema_manager_handler.type_schemas
-
-        if schema_type == SchemaTypes.USER:
-            return self._schema_manager_handler.user_schemas
-
-        return self._schema_manager_handler.all_schemas

amsdal/schemas/manager.pyi

@@ -1,65 +0,0 @@
-from _typeshed import Incomplete
-from amsdal.configs.main import settings as settings
-from amsdal_utils.models.data_models.schema import ObjectSchema as ObjectSchema
-from amsdal_utils.models.enums import SchemaTypes
-from amsdal_utils.utils.singleton import Singleton
-
-class SchemaManager(metaclass=Singleton):
-    """
-    Manages schema operations including retrieval, invalidation, and sorting.
-
-    This class handles various schema-related operations such as invalidating user schemas,
-    retrieving schemas by name or type, and sorting schemas based on predefined rules.
-    """
-    _schema_manager_handler: Incomplete
-    def __init__(self) -> None: ...
-    def invalidate_user_schemas(self) -> None:
-        """
-        Invalidates user schemas.
-
-        This method calls the handler to invalidate all user schemas, ensuring that any cached or outdated schemas
-            are refreshed.
-
-        Returns:
-            None
-        """
-    def class_schemas(self) -> list[tuple[ObjectSchema, SchemaTypes]]:
-        """
-        Returns a list of tuples containing object schemas and their types.
-
-        This method retrieves and sorts various schemas managed by the schema manager handler.
-        The schemas are categorized into types, core, user, and contrib schemas.
-
-        Returns:
-            list[tuple[ObjectSchema, SchemaTypes]]: A list of tuples where each tuple contains an object schema
-                and its corresponding type.
-        """
-    @staticmethod
-    def _sort_key_for_schema(schema: ObjectSchema) -> int: ...
-    def get_schema_by_name(self, title: str, schema_type: SchemaTypes | None = None) -> ObjectSchema | None:
-        """
-        Retrieves a schema by its title and optional type.
-
-        This method searches for a schema with the specified title and optional type
-        among the schemas managed by the schema manager handler.
-
-        Args:
-            title (str): The title of the schema to be retrieved.
-            schema_type (SchemaTypes | None, optional): The type of the schema to be retrieved. Defaults to None.
-
-        Returns:
-            ObjectSchema | None: The schema with the specified title and type, or None if not found.
-        """
-    def get_schemas(self, schema_type: SchemaTypes | None = None) -> list[ObjectSchema]:
-        """
-        Retrieves schemas based on the provided type.
-
-        This method returns a list of schemas filtered by the specified type. If no type is provided,
-        it returns all schemas managed by the schema manager handler.
-
-        Args:
-            schema_type (SchemaTypes | None, optional): The type of schemas to retrieve. Defaults to None.
-
-        Returns:
-            list[ObjectSchema]: A list of schemas filtered by the specified type, or all schemas if no type is provided.
-        """

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: ...

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/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]: ...

amsdal/services/__init__.py

@@ -0,0 +1,11 @@
+# AMSDAL services package
+
+from amsdal.services.external_connections import ExternalConnectionManager
+from amsdal.services.external_connections import ExternalDatabaseReader
+from amsdal.services.external_model_generator import ExternalModelGenerator
+
+__all__ = [
+    'ExternalConnectionManager',
+    'ExternalDatabaseReader',
+    'ExternalModelGenerator',
+]

amsdal/services/__init__.pyi

@@ -0,0 +1,4 @@
+from amsdal.services.external_connections import ExternalConnectionManager as ExternalConnectionManager, ExternalDatabaseReader as ExternalDatabaseReader
+from amsdal.services.external_model_generator import ExternalModelGenerator as ExternalModelGenerator
+
+__all__ = ['ExternalConnectionManager', 'ExternalDatabaseReader', 'ExternalModelGenerator']