amsdal 0.5.7__cp312-cp312-macosx_10_13_universal2.whl → 0.5.9__cp312-cp312-macosx_10_13_universal2.whl

amsdal/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present
 #
 # SPDX-License-Identifier: AMSDAL End User License Agreement
-__version__ = '0.5.7'
+__version__ = '0.5.9'

amsdal/__migrations__/0003_update_class_file.py

@@ -0,0 +1,91 @@
+from amsdal_models.migration import migrations
+from amsdal_utils.models.enums import ModuleType
+
+
+class Migration(migrations.Migration):
+    operations: list[migrations.Operation] = [
+        migrations.UpdateClass(
+            module_type=ModuleType.CORE,
+            class_name="File",
+            old_schema={
+                "title": "File",
+                "required": ["filename", "data"],
+                "properties": {
+                    "filename": {"type": "string", "title": "Filename"},
+                    "data": {"type": "binary", "title": "Data"},
+                    "size": {"type": "number", "title": "Size"},
+                },
+                "custom_code": 'import base64\nfrom pathlib import Path\nfrom typing import BinaryIO\n\nfrom pydantic import field_validator\n\n\n@classmethod\ndef from_file(cls, file_or_path: Path | BinaryIO) -> \'File\':\n    """\n        Creates a `File` object from a file path or a binary file object.\n\n        Args:\n            file_or_path (Path | BinaryIO): The file path or binary file object.\n\n        Returns:\n            File: The created `File` object.\n\n        Raises:\n            ValueError: If the provided path is a directory.\n        """\n    if isinstance(file_or_path, Path):\n        if file_or_path.is_dir():\n            msg = f\'{file_or_path} is a directory\'\n            raise ValueError(msg)\n        data = file_or_path.read_bytes()\n        filename = file_or_path.name\n    else:\n        file_or_path.seek(0)\n        data = file_or_path.read()\n        filename = Path(file_or_path.name).name\n    return cls(data=data, filename=filename)\n\n@field_validator(\'data\')\n@classmethod\ndef data_base64_decode(cls, v: bytes) -> bytes:\n    """\n        Decodes a base64-encoded byte string if it is base64-encoded.\n\n        This method checks if the provided byte string is base64-encoded and decodes it if true.\n        If the byte string is not base64-encoded, it returns the original byte string.\n\n        Args:\n            cls: The class this method belongs to.\n            v (bytes): The byte string to be checked and potentially decoded.\n\n        Returns:\n            bytes: The decoded byte string if it was base64-encoded, otherwise the original byte string.\n        """\n    is_base64: bool = False\n    try:\n        is_base64 = base64.b64encode(base64.b64decode(v)) == v\n    except Exception:\n        ...\n    if is_base64:\n        return base64.b64decode(v)\n    return v\n\n@property\ndef mimetype(self) -> str | None:\n    """\n        Returns the MIME type of the file based on its filename.\n\n        This method uses the `mimetypes` module to guess the MIME type of the file.\n\n        Returns:\n            str | None: The guessed MIME type of the file, or None if it cannot be determined.\n        """\n    import mimetypes\n    return mimetypes.guess_type(self.filename)[0]\n\nasync def apre_create(self) -> None:\n    """\n        Prepares the object for creation by setting its size attribute.\n\n        This method calculates the size of the object\'s data and assigns it to the size attribute.\n        If the data is None, it defaults to an empty byte string.\n\n        Args:\n            None\n        """\n    self.size = len(self.data or b\'\')\n\nasync def apre_update(self) -> None:\n    """\n        Prepares the object for update by setting its size attribute.\n\n        This method calculates the size of the object\'s data and assigns it to the size attribute.\n        If the data is None, it defaults to an empty byte string.\n\n        Args:\n            None\n        """\n    self.size = len(self.data or b\'\')\n\ndef __repr__(self) -> str:\n    return f\'File<{self.filename}>({self.size or len(self.data) or 0} bytes)\'\n\ndef __str__(self) -> str:\n    return repr(self)\n\ndef pre_create(self) -> None:\n    """\n        Prepares the object for creation by setting its size attribute.\n\n        This method calculates the size of the object\'s data and assigns it to the size attribute.\n        If the data is None, it defaults to an empty byte string.\n\n        Args:\n            None\n        """\n    self.size = len(self.data or b\'\')\n\ndef pre_update(self) -> None:\n    """\n        Prepares the object for update by setting its size attribute.\n\n        This method calculates the size of the object\'s data and assigns it to the size attribute.\n        If the data is None, it defaults to an empty byte string.\n\n        Args:\n            None\n        """\n    self.size = len(self.data or b\'\')\n\ndef to_file(self, file_or_path: Path | BinaryIO) -> None:\n    """\n        Writes the object\'s data to a file path or a binary file object.\n\n        Args:\n            file_or_path (Path | BinaryIO): The file path or binary file object where the data will be written.\n\n        Returns:\n            None\n\n        Raises:\n            ValueError: If the provided path is a directory.\n        """\n    if isinstance(file_or_path, Path):\n        if file_or_path.is_dir():\n            file_or_path = file_or_path / self.name\n        file_or_path.write_bytes(self.data)\n    else:\n        file_or_path.write(self.data)\n        file_or_path.seek(0)',
+                "storage_metadata": {
+                    "table_name": "File",
+                    "db_fields": {},
+                    "primary_key": ["partition_key"],
+                    "foreign_keys": {},
+                },
+            },
+            new_schema={
+                "title": "File",
+                "required": ["filename"],
+                "properties": {
+                    "filename": {"type": "string", "title": "Filename"},
+                    "data": {"type": "binary", "title": "Data"},
+                    "size": {"type": "number", "title": "Size"},
+                    "storage_address": {"type": "anything", "title": "Storage Reference"},
+                },
+                "custom_code": 'import base64\nimport io\nfrom contextlib import suppress\nfrom pathlib import Path\nfrom typing import IO\nfrom typing import Any\nfrom typing import BinaryIO\n\nfrom amsdal_models.storage.backends.db import DBStorage\nfrom amsdal_models.storage.base import Storage\nfrom pydantic import model_validator\n\n\n@classmethod\ndef data_base64_decode(cls, data: Any) -> bytes:\n    if isinstance(data, str):\n        data = data.encode(\'utf-8\')\n    is_base64: bool = False\n    with suppress(Exception):\n        is_base64 = base64.b64encode(base64.b64decode(data)) == data\n    if is_base64:\n        return base64.b64decode(data)\n    return data\n\n@classmethod\ndef from_bytes(cls, filename: str, data: bytes) -> \'File\':\n    """\n        Creates a `File` object from a byte string.\n\n        Args:\n            filename (str): The filename of the file.\n            data (bytes): The byte string containing the file data.:\n\n        Returns:\n            File: The created `File` object.\n        """\n    obj = cls(filename=filename, data=data, size=len(data))\n    obj._needs_persist = True\n    return obj\n\n@classmethod\ndef from_file(cls, file_or_path: Path | BinaryIO) -> \'File\':\n    """\n        Creates a `File` object from a file path or a binary file object.\n\n        Args:\n            file_or_path (Path | BinaryIO): The file path or binary file object.\n\n        Returns:\n            File: The created `File` object.\n\n        Raises:\n            ValueError: If the provided path is a directory.\n        """\n    f: BinaryIO | io.BufferedReader\n    if isinstance(file_or_path, Path):\n        if file_or_path.is_dir():\n            msg = f\'{file_or_path} is a directory\'\n            raise ValueError(msg)\n        f = file_or_path.open(\'rb\')\n        filename = file_or_path.name\n        size = file_or_path.stat().st_size\n    else:\n        f = file_or_path\n        filename = Path(getattr(f, \'name\', \'unnamed\')).name\n        try:\n            if f.seekable():\n                f.seek(0, io.SEEK_END)\n                size = f.tell()\n                f.seek(0)\n            else:\n                size = None\n        except (OSError, AttributeError):\n            size = None\n    obj = cls(filename=filename, size=size)\n    obj._source = f\n    obj._needs_persist = True\n    return obj\n\n@model_validator(mode=\'before\')\n@classmethod\ndef validate_model_data(cls, data: Any) -> Any:\n    if isinstance(data, dict):\n        if \'data\' in data:\n            if data[\'data\']:\n                data[\'data\'] = cls.data_base64_decode(data[\'data\'])\n                data[\'size\'] = len(data[\'data\'])\n            else:\n                data[\'size\'] = 0\n    return data\n\n@property\ndef mimetype(self) -> str | None:\n    """\n        Returns the MIME type of the file based on its filename.\n\n        This method uses the `mimetypes` module to guess the MIME type of the file.\n\n        Returns:\n            str | None: The guessed MIME type of the file, or None if it cannot be determined.\n        """\n    import mimetypes\n    return mimetypes.guess_type(self.filename)[0]\n\n@property\ndef storage(self) -> Storage:\n    from amsdal.storages import default_storage\n    if self._storage:\n        return self._storage\n    if self.storage_address:\n        return Storage.from_storage_spec({\'storage_class\': self.storage_address.ref.resource})\n    return default_storage()\n\nasync def aopen(self, mode: str=\'rb\') -> Any:\n    """\n        Async variant of open().\n\n        Uses the resolved storage to call aopen(); if the backend does not implement\n        async, falls back to the sync open().\n        """\n    try:\n        return await self.storage.aopen(self, mode)\n    except NotImplementedError:\n        return self.storage.open(self, mode)\n\nasync def apre_create(self) -> None:\n    if self._needs_persist:\n        from amsdal_models.storage.persistence import apersist_file\n        await apersist_file(self, storage=self.storage)\n\nasync def apre_update(self) -> None:\n    if self._needs_persist:\n        from amsdal_models.storage.persistence import apersist_file\n        await apersist_file(self, storage=self.storage)\n\nasync def aread_bytes(self) -> bytes:\n    async with await self.aopen() as f:\n        return await f.read()\n\nasync def aurl(self) -> str:\n    """\n        Async variant of url().\n\n        Uses the resolved storage to call aurl(); if the backend does not implement\n        async, falls back to the sync url().\n        """\n    try:\n        return await self.storage.aurl(self)\n    except NotImplementedError:\n        return self.storage.url(self)\n\ndef __repr__(self) -> str:\n    return f"File<{self.filename}>({self.size or len(self.data or \'\') or 0} bytes)"\n\ndef __str__(self) -> str:\n    return repr(self)\n\ndef open(self, mode: str=\'rb\') -> IO[Any]:\n    """\n        Open a binary stream for reading (or other modes if supported) using storage_address.\n\n        Raises StateError if storage_address is missing.\n        """\n    return self.storage.open(self, mode)\n\ndef pre_create(self) -> None:\n    if self._needs_persist:\n        from amsdal_models.storage.persistence import persist_file\n        persist_file(self, storage=self.storage)\n\ndef pre_update(self) -> None:\n    if self._needs_persist:\n        from amsdal_models.storage.persistence import persist_file\n        persist_file(self, storage=self.storage)\n\ndef read_bytes(self) -> bytes:\n    with self.open() as f:\n        return f.read()\n\ndef set_data(self, data: bytes | str) -> None:\n    if not isinstance(self.storage, DBStorage):\n        msg = \'Cannot set data on a file that is not stored in a database. Use `File.from_bytes` instead.\'\n        raise ValueError(msg)\n    self.data = self.data_base64_decode(data)\n    self.size = len(self.data)\n    self._needs_persist = True\n\ndef to_file(self, file_or_path: Path | BinaryIO) -> None:\n    """\n        Writes the object\'s data to a file path or a binary file object.\n\n        Args:\n            file_or_path (Path | BinaryIO): The file path or binary file object where the data will be written.\n\n        Returns:\n            None\n\n        Raises:\n            ValueError: If the provided path is a directory.\n        """\n    with self.open() as f:\n        if isinstance(file_or_path, Path):\n            if file_or_path.is_dir():\n                file_or_path = file_or_path / self.name\n            file_or_path.write_bytes(f.read())\n        else:\n            file_or_path.write(f.read())\n            file_or_path.seek(0)\n\ndef url(self) -> str:\n    """\n        Return a URL for this file using its storage_address.\n\n        Raises StateError if storage_address is missing.\n        """\n    return self.storage.url(self)',
+                "storage_metadata": {
+                    "table_name": "File",
+                    "db_fields": {},
+                    "primary_key": ["partition_key"],
+                    "foreign_keys": {},
+                },
+            },
+        ),
+        migrations.UpdateClass(
+            module_type=ModuleType.CORE,
+            class_name="ClassProperty",
+            old_schema={
+                "title": "ClassProperty",
+                "required": ["type"],
+                "properties": {
+                    "title": {"type": "string", "title": "Title"},
+                    "type": {"type": "string", "title": "Type"},
+                    "default": {"type": "anything", "title": "Default"},
+                    "options": {"type": "array", "items": {"type": "Option", "title": "Option"}, "title": "Options"},
+                    "items": {
+                        "type": "dictionary",
+                        "items": {"key": {"type": "string"}, "value": {"type": "anything"}},
+                        "title": "Items",
+                    },
+                    "discriminator": {"type": "string", "title": "Discriminator"},
+                },
+                "meta_class": "TypeMeta",
+                "custom_code": "from typing import Any\n\nfrom amsdal_models.builder.validators.dict_validators import validate_non_empty_keys\nfrom pydantic.functional_validators import field_validator\n\nfrom amsdal.models.core.option import *\n\n\n@field_validator('items')\n@classmethod\ndef _non_empty_keys_items(cls: type, value: Any) -> Any:\n    return validate_non_empty_keys(value)",
+                "storage_metadata": {"table_name": "ClassProperty", "db_fields": {}, "foreign_keys": {}},
+            },
+            new_schema={
+                "title": "ClassProperty",
+                "required": ["type"],
+                "properties": {
+                    "title": {"type": "string", "title": "Title"},
+                    "type": {"type": "string", "title": "Type"},
+                    "default": {"type": "anything", "title": "Default"},
+                    "options": {"type": "array", "items": {"type": "Option", "title": "Option"}, "title": "Options"},
+                    "items": {
+                        "type": "dictionary",
+                        "items": {"key": {"type": "string"}, "value": {"type": "anything"}},
+                        "title": "Items",
+                    },
+                    "discriminator": {"type": "string", "title": "Discriminator"},
+                    "extra": {
+                        "type": "dictionary",
+                        "items": {"key": {"type": "string"}, "value": {"type": "anything"}},
+                        "title": "Extra",
+                    },
+                },
+                "meta_class": "TypeMeta",
+                "custom_code": "from typing import Any\n\nfrom amsdal_models.builder.validators.dict_validators import validate_non_empty_keys\nfrom pydantic.functional_validators import field_validator\n\nfrom amsdal.models.core.option import *\n\n\n@field_validator('items')\n@classmethod\ndef _non_empty_keys_items(cls: type, value: Any) -> Any:\n    return validate_non_empty_keys(value)",
+                "storage_metadata": {"table_name": "ClassProperty", "db_fields": {}, "foreign_keys": {}},
+            },
+        ),
+    ]

amsdal/configs/main.py

@@ -71,6 +71,11 @@ class Settings(BaseSettings):
     CONTRIB_MODELS_PACKAGE_NAME: str = 'models'
     CONTRIB_MIGRATIONS_DIRECTORY_NAME: str = 'migrations'
 
+    # File Storage
+    AMSDAL_MEDIA_ROOT: Path = Path('./media')
+    AMSDAL_MEDIA_URL: str = '/media/'
+    AMSDAL_DEFAULT_FILE_STORAGE: str = 'amsdal_models.storage.backends.db.DBStorage'
+
     @field_validator('CONTRIBS', mode='after')
     def load_contrib_modules(cls, value: list[str]) -> list[str]:  # noqa: N805
         """

amsdal/configs/main.pyi

@@ -52,6 +52,9 @@ class Settings(BaseSettings):
     CONTRIBS: list[str]
     CONTRIB_MODELS_PACKAGE_NAME: str
     CONTRIB_MIGRATIONS_DIRECTORY_NAME: str
+    AMSDAL_MEDIA_ROOT: Path
+    AMSDAL_MEDIA_URL: str
+    AMSDAL_DEFAULT_FILE_STORAGE: str
     def load_contrib_modules(cls, value: list[str]) -> list[str]:
         """
         Loads and initializes contrib modules.

amsdal/contrib/auth/lifecycle/consumer.pyi

@@ -1,7 +1,7 @@
 from _typeshed import Incomplete
 from amsdal.contrib.auth.errors import AuthenticationError as AuthenticationError
 from amsdal_data.transactions.decorators import async_transaction, transaction
-from amsdal_models.classes.model import Model as Model
+from amsdal_models.classes.model import Model
 from amsdal_utils.lifecycle.consumer import LifecycleConsumer
 from typing import Any
 

amsdal/fixtures/manager.pyi

@@ -1,6 +1,6 @@
 from _typeshed import Incomplete
 from amsdal.fixtures.utils import process_fixture_value as process_fixture_value
-from amsdal_models.classes.model import Model as Model
+from amsdal_models.classes.model import Model
 from collections.abc import Generator
 from pathlib import Path
 from pydantic import BaseModel

amsdal/models/core/class_property.py

@@ -18,6 +18,7 @@ class ClassProperty(TypeModel):
     options: list['Option'] | None = Field(None, title='Options')  # noqa: F405
     items: dict[str, Any | None] | None = Field(None, title='Items')
     discriminator: str | None = Field(None, title='Discriminator')
+    extra: dict[str, Any | None] = Field(default_factory=dict, title='Extra')
 
     @field_validator('items')
     @classmethod

amsdal/models/core/file.py

@@ -1,74 +1,101 @@
 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 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)
+    _needs_persist: bool = PrivateAttr(default=False)
+    _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:
+        if self._needs_persist:
+            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:
+        if self._needs_persist:
+            from amsdal_models.storage.persistence import persist_file
+
+            persist_file(self, storage=self.storage)
+
+    async def apre_create(self) -> None:
+        if self._needs_persist:
+            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.
+        if self._needs_persist:
+            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 +111,140 @@ 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
+        obj._needs_persist = True
+        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))
+        obj._needs_persist = True
+        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 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)
+        self._needs_persist = True

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)