amsdal 0.3.6__cp312-cp312-macosx_10_13_universal2.whl → 0.4.0__cp312-cp312-macosx_10_13_universal2.whl

amsdal/models/core/class_object_meta.pyi

@@ -0,0 +1,15 @@
+from amsdal.models.core.class_property_meta import *
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from typing import Any, ClassVar
+
+class ClassObjectMeta(Model):
+    __module_type__: ClassVar[ModuleType] = ...
+    title: str = ...
+    type: str = ...
+    default: Any | None = ...
+    class_schema_type: str | None = ...
+    properties: dict[str, ClassPropertyMeta | None] | None = ...
+    custom_code: str | None = ...
+    @classmethod
+    def _non_empty_keys_properties(cls, value: Any) -> Any: ...

amsdal/models/core/class_property.py

@@ -0,0 +1,19 @@
+from typing import Any
+from typing import ClassVar
+
+from amsdal_models.builder.validators.dict_validators import validate_non_empty_keys
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+from pydantic.functional_validators import field_validator
+
+
+class ClassProperty(TypeModel):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    type: str = Field(title='Type')
+    items: dict[str, Any | None] | None = Field(None, title='Items')
+
+    @field_validator('items')
+    @classmethod
+    def _non_empty_keys_items(cls: type, value: Any) -> Any:  # type: ignore # noqa: A003
+        return validate_non_empty_keys(value)

amsdal/models/core/class_property.pyi

@@ -0,0 +1,10 @@
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from typing import Any, ClassVar
+
+class ClassProperty(TypeModel):
+    __module_type__: ClassVar[ModuleType]
+    type: str
+    items: dict[str, Any | None] | None
+    @classmethod
+    def _non_empty_keys_items(cls, value: Any) -> Any: ...

amsdal/models/core/class_property_meta.py

@@ -0,0 +1,15 @@
+from typing import Any
+from typing import ClassVar
+
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+
+from amsdal.models.core.option import *  # noqa: F403
+
+
+class ClassPropertyMeta(TypeModel):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    title: str | None = Field(None, title='Title')
+    default: Any | None = Field(None, title='Default')
+    options: list['Option'] | None = Field(None, title='Options')  # noqa: F405

amsdal/models/core/class_property_meta.pyi

@@ -0,0 +1,10 @@
+from amsdal.models.core.option import *
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from typing import Any, ClassVar
+
+class ClassPropertyMeta(TypeModel):
+    __module_type__: ClassVar[ModuleType]
+    title: str | None
+    default: Any | None
+    options: list['Option'] | None

amsdal/models/core/file.py

@@ -0,0 +1,156 @@
+import base64
+from pathlib import Path
+from typing import BinaryIO
+from typing import ClassVar
+
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from pydantic import field_validator
+from pydantic.fields import Field
+
+
+class File(Model):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    filename: str = Field(title='Filename')
+    data: bytes = Field(title='Data')
+    size: float | None = Field(None, title='Size')
+
+    def __repr__(self) -> str:
+        return f'File<{self.filename}>({self.size or len(self.data) or 0} bytes)'
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    async def apre_create(self) -> None:
+        """
+        Prepares the object for creation by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+        self.size = len(self.data or b'')
+
+    async def apre_update(self) -> None:
+        """
+        Prepares the object for update by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+        self.size = len(self.data or b'')
+
+    @field_validator('data')
+    @classmethod
+    def data_base64_decode(cls, v: bytes) -> bytes:
+        """
+        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
+        try:
+            is_base64 = base64.b64encode(base64.b64decode(v)) == v
+        except Exception:
+            ...
+        if is_base64:
+            return base64.b64decode(v)
+        return v
+
+    @classmethod
+    def from_file(cls, file_or_path: Path | BinaryIO) -> 'File':
+        """
+        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)  # type: ignore[call-arg]
+
+    @property
+    def mimetype(self) -> str | None:
+        """
+        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]
+
+    def pre_create(self) -> None:
+        """
+        Prepares the object for creation by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+        self.size = len(self.data or b'')
+
+    def pre_update(self) -> None:
+        """
+        Prepares the object for update by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+        self.size = len(self.data or b'')
+
+    def to_file(self, file_or_path: Path | BinaryIO) -> None:
+        """
+        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/models/core/file.pyi

@@ -0,0 +1,104 @@
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from pathlib import Path
+from typing import BinaryIO, ClassVar
+
+class File(Model):
+    __module_type__: ClassVar[ModuleType] = ...
+    filename: str = ...
+    data: bytes = ...
+    size: float | None = ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    async def apre_create(self) -> None:
+        """
+        Prepares the object for creation by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+    async def apre_update(self) -> None:
+        """
+        Prepares the object for update by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+    @classmethod
+    def data_base64_decode(cls, v: bytes) -> bytes:
+        """
+        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.
+        """
+    @classmethod
+    def from_file(cls, file_or_path: Path | BinaryIO) -> File:
+        """
+        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.
+        """
+    @property
+    def mimetype(self) -> str | None:
+        """
+        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.
+        """
+    def pre_create(self) -> None:
+        """
+        Prepares the object for creation by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+    def pre_update(self) -> None:
+        """
+        Prepares the object for update by setting its size attribute.
+
+        This method calculates the size of the object's data and assigns it to the size attribute.
+        If the data is None, it defaults to an empty byte string.
+
+        Args:
+            None
+        """
+    def to_file(self, file_or_path: Path | BinaryIO) -> None:
+        """
+        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.
+        """

amsdal/models/core/fixture.py

@@ -0,0 +1,25 @@
+from typing import Any
+from typing import ClassVar
+
+from amsdal_models.builder.validators.dict_validators import validate_non_empty_keys
+from amsdal_models.classes.data_models.constraints import UniqueConstraint
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+from pydantic.functional_validators import field_validator
+
+
+class Fixture(Model):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    __constraints__: ClassVar[list[UniqueConstraint]] = [
+        UniqueConstraint(name='unq_fixture_external_id', fields=['external_id'])
+    ]
+    class_name: str | None = Field(None, title='Class Name')
+    order: float | None = Field(None, title='Order')
+    external_id: str = Field(title='External ID')
+    data: dict[str, Any | None] = Field(title='Data')
+
+    @field_validator('data')
+    @classmethod
+    def _non_empty_keys_data(cls: type, value: Any) -> Any:
+        return validate_non_empty_keys(value)

amsdal/models/core/fixture.pyi

@@ -0,0 +1,14 @@
+from amsdal_models.classes.data_models.constraints import UniqueConstraint
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from typing import Any, ClassVar
+
+class Fixture(Model):
+    __module_type__: ClassVar[ModuleType] = ...
+    __constraints__: ClassVar[list[UniqueConstraint]] = ...
+    class_name: str | None = ...
+    order: float | None = ...
+    external_id: str = ...
+    data: dict[str, Any | None] = ...
+    @classmethod
+    def _non_empty_keys_data(cls, value: Any) -> Any: ...

amsdal/models/core/option.py

@@ -0,0 +1,11 @@
+from typing import ClassVar
+
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+
+
+class Option(TypeModel):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    key: str = Field(title='Key')
+    value: str = Field(title='Value Type')

amsdal/models/core/option.pyi

@@ -0,0 +1,8 @@
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from typing import ClassVar
+
+class Option(TypeModel):
+    __module_type__: ClassVar[ModuleType]
+    key: str
+    value: str

amsdal/models/core/validator.py

@@ -0,0 +1,12 @@
+from typing import Any
+from typing import ClassVar
+
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+
+
+class Validator(TypeModel):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    name: str = Field(title='Validator Name')
+    data: Any = Field(title='Validator Data')

amsdal/models/core/validator.pyi

@@ -0,0 +1,8 @@
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from typing import Any, ClassVar
+
+class Validator(TypeModel):
+    __module_type__: ClassVar[ModuleType]
+    name: str
+    data: Any

amsdal/models/types/object.py

@@ -0,0 +1,26 @@
+from typing import Any
+from typing import ClassVar
+from typing import Optional
+
+from amsdal_models.builder.validators.dict_validators import validate_non_empty_keys
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+from pydantic.functional_validators import field_validator
+
+
+class Object(Model):
+    __module_type__: ClassVar[ModuleType] = ModuleType.TYPE
+    title: Optional[str] = Field(None, title='Title')  # noqa: UP007
+    type: Optional[str] = Field(None, title='Type')  # noqa: UP007
+    default: Optional[Any] = Field(None, title='Default')  # noqa: UP007
+    properties: Optional[dict[str, Optional[Any]]] = Field(None, title='Properties')  # noqa: UP007
+    required: Optional[list[str]] = Field(None, title='Required')  # noqa: UP007
+    unique: Optional[list[list[str]]] = Field(None, title='Unique Fields')  # noqa: UP007
+    custom_code: Optional[str] = Field(None, title='Custom Code')  # noqa: UP007
+    meta_class: Optional[str] = Field(None, title='Meta Class')  # noqa: UP007
+
+    @field_validator('properties')
+    @classmethod
+    def _non_empty_keys_properties(cls: type, value: Any) -> Any:  # type: ignore # noqa: A003
+        return validate_non_empty_keys(value)

amsdal/models/types/object.pyi

@@ -0,0 +1,16 @@
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.enums import ModuleType
+from typing import Any, ClassVar
+
+class Object(Model):
+    __module_type__: ClassVar[ModuleType] = ...
+    title: str | None = ...
+    type: str | None = ...
+    default: Any | None = ...
+    properties: dict[str, Any | None] | None = ...
+    required: list[str] | None = ...
+    unique: list[list[str]] | None = ...
+    custom_code: str | None = ...
+    meta_class: str | None = ...
+    @classmethod
+    def _non_empty_keys_properties(cls, value: Any) -> Any: ...

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

@@ -5,7 +5,7 @@ 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]  # noqa: ARG001
+def data_base64_decode(cls, v: bytes) -> bytes:  # type: ignore[no-untyped-def]
     """
     Decodes a base64-encoded byte string if it is base64-encoded.
 

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
+
+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/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