amsdal 0.4.10__cp312-cp312-macosx_10_13_universal2.whl → 0.5.33__cp312-cp312-macosx_10_13_universal2.whl

amsdal/models/core/file.py

@@ -1,74 +1,97 @@
 import base64
+import io
+from contextlib import suppress
 from pathlib import Path
+from typing import IO
+from typing import Any
 from typing import BinaryIO
 from typing import ClassVar
 
 from amsdal_models.classes.model import Model
+from amsdal_models.storage.backends.db import AsyncFileWrapper
+from amsdal_models.storage.backends.db import DBStorage
+from amsdal_models.storage.base import Storage
+from amsdal_utils.models.data_models.reference import Reference
 from amsdal_utils.models.enums import ModuleType
-from pydantic import field_validator
+from pydantic import PrivateAttr
+from pydantic import model_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')
+    data: bytes | None = Field(default=None, title='Data')
+    size: float | None = Field(default=None, title='Size')
+    storage_address: Reference | None = Field(default=None, title='Storage Reference')
+
+    _source: BinaryIO | None = PrivateAttr(default=None)
+    _storage: Storage | None = PrivateAttr(default=None)
+
+    @property
+    def storage(self) -> Storage:
+        from amsdal.storages import default_storage
+
+        if self._storage:
+            return self._storage
+
+        if self.storage_address:
+            return Storage.from_storage_spec({'storage_class': self.storage_address.ref.resource})
+
+        return default_storage()
 
     def __repr__(self) -> str:
-        return f'File<{self.filename}>({self.size or len(self.data) or 0} bytes)'
+        return f'File<{self.filename}>({self.size or len(self.data or "") 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.
+    def pre_create(self) -> None:
+        from amsdal_models.storage.persistence import persist_file
 
-        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.
+        persist_file(self, storage=self.storage)
 
-        Args:
-            None
-        """
-        self.size = len(self.data or b'')
+    def pre_update(self) -> None:
+        from amsdal_models.storage.persistence import persist_file
+
+        persist_file(self, storage=self.storage)
+
+    async def apre_create(self) -> None:
+        from amsdal_models.storage.persistence import apersist_file
+
+        await apersist_file(self, storage=self.storage)
 
     async def apre_update(self) -> None:
-        """
-        Prepares the object for update by setting its size attribute.
+        from amsdal_models.storage.persistence import apersist_file
 
-        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.
+        await apersist_file(self, storage=self.storage)
 
-        Args:
-            None
-        """
-        self.size = len(self.data or b'')
+    @model_validator(mode='before')
+    @classmethod
+    def validate_model_data(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if 'data' in data:
+                if data['data']:
+                    data['data'] = cls.data_base64_decode(data['data'])
+                    data['size'] = len(data['data'])
+                else:
+                    data['size'] = 0
+        return data
 
-    @field_validator('data')
     @classmethod
-    def data_base64_decode(cls, v: bytes) -> bytes:
-        """
-        Decodes a base64-encoded byte string if it is base64-encoded.
+    def data_base64_decode(cls, data: Any) -> bytes:
+        if isinstance(data, str):
+            data = data.encode('utf-8')
 
-        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.
+        is_base64: bool = False
 
-        Args:
-            cls: The class this method belongs to.
-            v (bytes): The byte string to be checked and potentially decoded.
+        with suppress(Exception):
+            is_base64 = base64.b64encode(base64.b64decode(data)) == data
 
-        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
+            return base64.b64decode(data)
+
+        return data
 
     @classmethod
     def from_file(cls, file_or_path: Path | BinaryIO) -> 'File':
@@ -84,73 +107,137 @@ class File(Model):
         Raises:
             ValueError: If the provided path is a directory.
         """
+        f: BinaryIO | io.BufferedReader
+
         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()
+            f = file_or_path.open('rb')
             filename = file_or_path.name
+            size = file_or_path.stat().st_size
+
         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]
+            f = file_or_path
+            filename = Path(getattr(f, 'name', 'unnamed')).name
+
+            try:
+                if f.seekable():
+                    f.seek(0, io.SEEK_END)
+                    size = f.tell()
+                    f.seek(0)
+                else:
+                    size = None
+            except (OSError, AttributeError):
+                size = None
+
+        obj = cls(filename=filename, size=size)
+        obj._source = f
+        return obj
 
-    @property
-    def mimetype(self) -> str | None:
+    @classmethod
+    def from_bytes(cls, filename: str, data: bytes) -> 'File':
         """
-        Returns the MIME type of the file based on its filename.
+        Creates a `File` object from a byte string.
 
-        This method uses the `mimetypes` module to guess the MIME type of the file.
+        Args:
+            filename (str): The filename of the file.
+            data (bytes): The byte string containing the file data.:
 
         Returns:
-            str | None: The guessed MIME type of the file, or None if it cannot be determined.
+            File: The created `File` object.
         """
-        import mimetypes
+        obj = cls(filename=filename, data=data, size=len(data))
+        return obj
 
-        return mimetypes.guess_type(self.filename)[0]
-
-    def pre_create(self) -> None:
+    def to_file(self, file_or_path: Path | BinaryIO) -> 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.
+        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.
         """
-        self.size = len(self.data or b'')
+        with self.open() as f:
+            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(f.read())  # type: ignore[union-attr]
+            else:
+                file_or_path.write(f.read())
+                file_or_path.seek(0)
 
-    def pre_update(self) -> None:
+    def url(self) -> str:
         """
-        Prepares the object for update by setting its size attribute.
+        Return a URL for this file using its storage_address.
 
-        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.
+        Raises StateError if storage_address is missing.
+        """
+        return self.storage.url(self)
 
-        Args:
-            None
+    def open(self, mode: str = 'rb') -> IO[Any]:
         """
-        self.size = len(self.data or b'')
+        Open a binary stream for reading (or other modes if supported) using storage_address.
 
-    def to_file(self, file_or_path: Path | BinaryIO) -> None:
+        Raises StateError if storage_address is missing.
         """
-        Writes the object's data to a file path or a binary file object.
+        return self.storage.open(self, mode)
 
-        Args:
-            file_or_path (Path | BinaryIO): The file path or binary file object where the data will be written.
+    async def aurl(self) -> str:
+        """
+        Async variant of url().
 
-        Returns:
-            None
+        Uses the resolved storage to call aurl(); if the backend does not implement
+        async, falls back to the sync url().
+        """
+        try:
+            return await self.storage.aurl(self)  # type: ignore[attr-defined]
+        except NotImplementedError:
+            return self.storage.url(self)
 
-        Raises:
-            ValueError: If the provided path is a directory.
+    async def aopen(self, mode: str = 'rb') -> Any:
         """
-        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)
+        Async variant of open().
+
+        Uses the resolved storage to call aopen(); if the backend does not implement
+        async, falls back to the sync open().
+        """
+        try:
+            return await self.storage.aopen(self, mode)
+        except NotImplementedError:
+            return AsyncFileWrapper(self.storage.open(self, mode))
+
+    @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 read_bytes(self) -> bytes:
+        with self.open() as f:
+            return f.read()
+
+    async def aread_bytes(self) -> bytes:
+        async with await self.aopen() as f:
+            return await f.read()
+
+    def set_data(self, data: bytes | str) -> None:
+        if not isinstance(self.storage, DBStorage):
+            msg = 'Cannot set data on a file that is not stored in a database. Use `File.from_bytes` instead.'
+            raise ValueError(msg)
+
+        self.data = self.data_base64_decode(data)
+        self.size = len(self.data)

amsdal/models/core/storage_metadata.py

@@ -0,0 +1,15 @@
+from typing import ClassVar
+from typing import Optional
+
+from amsdal_models.classes.model import TypeModel
+from amsdal_utils.models.enums import ModuleType
+from pydantic.fields import Field
+
+
+class StorageMetadata(TypeModel):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    table_name: Optional[str] = Field(None, title='Table name')  # noqa: UP007
+    db_fields: dict[str, list[str]] | None = Field(None, title='Database fields')
+    primary_key: Optional[list[str]] = Field(None, title='Primary key fields')  # noqa: UP007
+    indexed: Optional[list[list[str]]] = Field(None, title='Indexed')  # noqa: UP007
+    unique: Optional[list[list[str]]] = Field(None, title='Unique Fields')  # noqa: UP007

amsdal/models/mixins.py

@@ -0,0 +1,31 @@
+import datetime as _dt
+
+
+class TimestampMixin:
+    created_at: _dt.datetime | None = None
+    updated_at: _dt.datetime | None = None
+
+    def pre_create(self) -> None:
+        self.created_at = _dt.datetime.now(tz=_dt.UTC)
+        super().pre_create()  # type: ignore[misc]
+
+    async def apre_create(self) -> None:
+        self.created_at = _dt.datetime.now(tz=_dt.UTC)
+        await super().apre_create()  # type: ignore[misc]
+
+    def pre_update(self) -> None:
+        self.updated_at = _dt.datetime.now(tz=_dt.UTC)
+
+        if not self.created_at:
+            _metadata = self.get_metadata()  # type: ignore[attr-defined]
+            self.created_at = _dt.datetime.fromtimestamp(_metadata.created_at / 1000, tz=_dt.UTC)
+
+        super().pre_update()  # type: ignore[misc]
+
+    async def apre_update(self) -> None:
+        self.updated_at = _dt.datetime.now(tz=_dt.UTC)
+        if not self.created_at:
+            _metadata = await self.aget_metadata()  # type: ignore[attr-defined]
+            self.created_at = _dt.datetime.fromtimestamp(_metadata.created_at / 1000, tz=_dt.UTC)
+
+        await super().apre_update()  # type: ignore[misc]

amsdal/models/types/object.py

@@ -11,12 +11,12 @@ 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
+    title: str = Field(title='Title', default='')
+    type: str = Field(title='Type', default='object')
+    module_type: str = Field(title='Module Type', default=ModuleType.CORE.value)
     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
 

amsdal/schemas/core/class_object/model.json

@@ -2,6 +2,18 @@
   "title": "ClassObject",
   "type": "object",
   "properties": {
+    "title": {
+      "title": "Title",
+      "type": "string"
+    },
+    "type": {
+      "title": "Type",
+      "type": "string"
+    },
+    "module_type": {
+      "title": "Module Type",
+      "type": "string"
+    },
     "properties": {
       "title": "Properties",
       "type": "dictionary",
@@ -21,6 +33,14 @@
         "type": "string"
       }
     },
+    "custom_code": {
+      "title": "Custom Code",
+      "type": "string"
+    },
+    "storage_metadata": {
+      "title": "Storage metadata",
+      "type": "StorageMetadata"
+    },
     "meta_class": {
       "title": "Meta Class",
       "type": "string",

amsdal/schemas/core/class_property/model.json

@@ -2,10 +2,25 @@
   "title": "ClassProperty",
   "type": "object",
   "properties": {
+    "title": {
+      "title": "Title",
+      "type": "string"
+    },
     "type": {
       "title": "Type",
       "type": "string"
     },
+    "default": {
+      "title": "Default",
+      "type": "anything"
+    },
+    "options": {
+      "title": "Options",
+      "type": "array",
+      "items": {
+        "type": "Option"
+      }
+    },
     "items": {
       "title": "Items",
       "type": "dictionary",
@@ -13,6 +28,10 @@
         "key": {"type": "string"},
         "value": {"type": "anything"}
       }
+    },
+    "discriminator": {
+      "title": "Discriminator",
+      "type": "string"
     }
   },
   "required": [

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

@@ -1,4 +1,5 @@
 import base64
+from contextlib import suppress
 
 from pydantic import field_validator
 
@@ -21,10 +22,8 @@ def data_base64_decode(cls, v: bytes) -> bytes:  # type: ignore[no-untyped-def]
     """
     is_base64: bool = False
 
-    try:
+    with suppress(Exception):
         is_base64 = base64.b64encode(base64.b64decode(v)) == v
-    except Exception:
-        ...
 
     if is_base64:
         return base64.b64decode(v)

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/interfaces.pyi

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
 from typing import TypeAlias
 
-ModulePathType: TypeAlias
+ModulePathType: TypeAlias = str
 
 class BaseSchemaLoader(ABC, metaclass=abc.ABCMeta):
     @property

amsdal/schemas/mixins/check_dependencies_mixin.py

@@ -74,12 +74,17 @@ class CheckDependenciesMixin:
         ):
             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)
+                    _dependencies = [_dependency]
+                    if '|' in _dependency:
+                        _dependencies = [dep.strip() for dep in _dependency.split('|')]
 
-    @staticmethod
-    def get_dependency_type_names(schema: ObjectSchema) -> set[str]:
+                    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.
 
@@ -97,19 +102,29 @@ class CheckDependenciesMixin:
         }
 
         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):
-                _dependencies.add(_property.items.type)
+                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):
-                    _dependencies.add(_property.items.key.type)
-                    _dependencies.add(_property.items.value.type)
+                    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

@@ -1,3 +1,4 @@
+from amsdal_utils.models.data_models.core import TypeData
 from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
 
 class CheckDependenciesMixin:
@@ -26,8 +27,8 @@ class CheckDependenciesMixin:
         Returns:
             None
         """
-    @staticmethod
-    def get_dependency_type_names(schema: ObjectSchema) -> set[str]:
+    @classmethod
+    def get_dependency_type_names(cls, schema: ObjectSchema) -> set[str]:
         """
         Returns a set of dependency type names for the given schema.
 
@@ -40,3 +41,5 @@ class CheckDependenciesMixin:
         Returns:
             set[str]: A set of dependency type names for the given schema.
         """
+    @classmethod
+    def _is_enum(cls, _type: TypeData) -> bool: ...

amsdal/schemas/utils.pyi

@@ -1,8 +1,8 @@
 from amsdal_utils.models.enums import ModuleType as ModuleType
 from typing import TypeAlias
 
-ModulePathType: TypeAlias
-ClassNameType: TypeAlias
+ModulePathType: TypeAlias = str
+ClassNameType: TypeAlias = str
 
 class ModelModuleInfo:
     _info: dict[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']