amsdal 0.5.23__cp311-cp311-macosx_10_9_universal2.whl

amsdal/mixins/class_versions_mixin.pyi

@@ -0,0 +1,12 @@
+from amsdal_data.connections.historical.schema_version_manager import AsyncHistoricalSchemaVersionManager, HistoricalSchemaVersionManager
+
+class ClassVersionsMixin:
+    """
+    Mixin class to manage class versions and related table schemas.
+    """
+    @staticmethod
+    def _register_internal_classes(schema_version_manager: HistoricalSchemaVersionManager | AsyncHistoricalSchemaVersionManager) -> None: ...
+    @classmethod
+    def register_internal_classes(cls) -> None: ...
+    @classmethod
+    def aregister_internal_classes(cls) -> None: ...

amsdal/models/__init__.py

@@ -0,0 +1,19 @@
+from amsdal_models.builder.validators.dict_validators import validate_non_empty_keys
+from amsdal_models.builder.validators.options_validators import validate_options
+from amsdal_models.classes.data_models.constraints import UniqueConstraint
+from amsdal_models.classes.data_models.indexes import IndexInfo
+from amsdal_models.classes.model import Model
+from amsdal_models.classes.model import TypeModel
+from amsdal_models.classes.relationships.many_reference_field import ManyReferenceField
+from amsdal_models.classes.relationships.reference_field import ReferenceField
+
+__all__ = [
+    'IndexInfo',
+    'ManyReferenceField',
+    'Model',
+    'ReferenceField',
+    'TypeModel',
+    'UniqueConstraint',
+    'validate_non_empty_keys',
+    'validate_options',
+]

amsdal/models/core/class_object.py

@@ -0,0 +1,38 @@
+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
+
+from amsdal.models.core.class_property import *  # noqa: F403
+from amsdal.models.core.storage_metadata import *  # noqa: F403
+
+
+class ClassObject(Model):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    title: str = Field(title='Title')
+    type: str = Field(title='Type')
+    module_type: str = Field(title='Module Type')
+    properties: Optional[dict[str, Optional['ClassProperty']]] = Field(None, title='Properties')  # noqa: F405, UP007
+    required: Optional[list[str]] = Field(None, title='Required')  # noqa: UP007
+    custom_code: str | None = Field(None, title='Custom Code')
+    storage_metadata: Optional['StorageMetadata'] = Field(None, title='Storage metadata')  # noqa: F405
+
+    @field_validator('properties')
+    @classmethod
+    def _non_empty_keys_properties(cls: type, value: Any) -> Any:  # type: ignore # noqa: A003
+        return validate_non_empty_keys(value)
+
+    @property
+    def display_name(self) -> str:
+        """
+        Returns the display name of the object.
+
+        Returns:
+            str: The display name, which is the title of the object.
+        """
+        return self.title

amsdal/models/core/class_property.py

@@ -0,0 +1,26 @@
+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
+
+from amsdal.models.core.option import *  # noqa: F403
+
+
+class ClassProperty(TypeModel):
+    __module_type__: ClassVar[ModuleType] = ModuleType.CORE
+    title: str | None = Field(None, title='Title')
+    type: str = Field(title='Type')
+    default: Any | None = Field(None, title='Default')
+    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
+    def _non_empty_keys_items(cls: type, value: Any) -> Any:  # type: ignore # noqa: A003
+        return validate_non_empty_keys(value)

amsdal/models/core/file.py

@@ -0,0 +1,243 @@
+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 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 | 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 "") or 0} bytes)'
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def pre_create(self) -> None:
+        from amsdal_models.storage.persistence import persist_file
+
+        persist_file(self, storage=self.storage)
+
+    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:
+        from amsdal_models.storage.persistence import apersist_file
+
+        await apersist_file(self, storage=self.storage)
+
+    @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
+
+    @classmethod
+    def data_base64_decode(cls, data: Any) -> bytes:
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+
+        is_base64: bool = False
+
+        with suppress(Exception):
+            is_base64 = base64.b64encode(base64.b64decode(data)) == data
+
+        if is_base64:
+            return base64.b64decode(data)
+
+        return data
+
+    @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.
+        """
+        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)
+            f = file_or_path.open('rb')
+            filename = file_or_path.name
+            size = file_or_path.stat().st_size
+
+        else:
+            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
+
+    @classmethod
+    def from_bytes(cls, filename: str, data: bytes) -> 'File':
+        """
+        Creates a `File` object from a byte string.
+
+        Args:
+            filename (str): The filename of the file.
+            data (bytes): The byte string containing the file data.:
+
+        Returns:
+            File: The created `File` object.
+        """
+        obj = cls(filename=filename, data=data, size=len(data))
+        return obj
+
+    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.
+        """
+        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 url(self) -> str:
+        """
+        Return a URL for this file using its storage_address.
+
+        Raises StateError if storage_address is missing.
+        """
+        return self.storage.url(self)
+
+    def open(self, mode: str = 'rb') -> IO[Any]:
+        """
+        Open a binary stream for reading (or other modes if supported) using storage_address.
+
+        Raises StateError if storage_address is missing.
+        """
+        return self.storage.open(self, mode)
+
+    async def aurl(self) -> str:
+        """
+        Async variant of url().
+
+        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)
+
+    async def aopen(self, mode: str = 'rb') -> Any:
+        """
+        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/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/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/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/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/mixins.py

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

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: 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
+    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/queryset/__init__.py

@@ -0,0 +1,21 @@
+from amsdal_models.querysets.base_queryset import QuerySet
+from amsdal_models.querysets.base_queryset import QuerySetCount
+from amsdal_models.querysets.base_queryset import QuerySetOne
+from amsdal_models.querysets.base_queryset import QuerySetOneRequired
+from amsdal_utils.query.data_models.filter import Filter
+from amsdal_utils.query.enums import Lookup
+from amsdal_utils.query.enums import OrderDirection
+from amsdal_utils.query.utils import ConnectorEnum
+from amsdal_utils.query.utils import Q
+
+__all__ = [
+    'ConnectorEnum',
+    'Filter',
+    'Lookup',
+    'OrderDirection',
+    'Q',
+    'QuerySet',
+    'QuerySetCount',
+    'QuerySetOne',
+    'QuerySetOneRequired',
+]

amsdal/queryset/__init__.pyi

@@ -0,0 +1,6 @@
+from amsdal_models.querysets.base_queryset import QuerySet as QuerySet, QuerySetCount as QuerySetCount, QuerySetOne as QuerySetOne, QuerySetOneRequired as QuerySetOneRequired
+from amsdal_utils.query.data_models.filter import Filter as Filter
+from amsdal_utils.query.enums import Lookup as Lookup, OrderDirection as OrderDirection
+from amsdal_utils.query.utils import ConnectorEnum as ConnectorEnum, Q as Q
+
+__all__ = ['ConnectorEnum', 'Filter', 'Lookup', 'OrderDirection', 'Q', 'QuerySet', 'QuerySetCount', 'QuerySetOne', 'QuerySetOneRequired']

amsdal/schemas/core/class_object/model.json

@@ -0,0 +1,51 @@
+{
+  "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",
+      "items": {
+        "key": {
+          "type": "string"
+        },
+        "value": {
+          "type": "ClassProperty"
+        }
+      }
+    },
+    "required": {
+      "title": "Required",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "custom_code": {
+      "title": "Custom Code",
+      "type": "string"
+    },
+    "storage_metadata": {
+      "title": "Storage metadata",
+      "type": "StorageMetadata"
+    },
+    "meta_class": {
+      "title": "Meta Class",
+      "type": "string",
+      "default": "ClassObject"
+    }
+  },
+  "required": []
+}

amsdal/schemas/core/class_object/properties/display_name.py

@@ -0,0 +1,9 @@
+@property  # type: ignore[misc]
+def display_name(self) -> str:  # type: ignore[no-untyped-def]
+    """
+    Returns the display name of the object.
+
+    Returns:
+        str: The display name, which is the title of the object.
+    """
+    return self.title

amsdal/schemas/core/class_property/model.json

@@ -0,0 +1,41 @@
+{
+  "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",
+      "items": {
+        "key": {"type": "string"},
+        "value": {"type": "anything"}
+      }
+    },
+    "discriminator": {
+      "title": "Discriminator",
+      "type": "string"
+    }
+  },
+  "required": [
+    "type"
+  ],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/core/file/hooks/pre_create.py

@@ -0,0 +1,24 @@
+def pre_create(self) -> None:  # type: ignore[no-untyped-def]
+    """
+    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_create(self) -> None:  # type: ignore[no-untyped-def]
+    """
+    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'')

amsdal/schemas/core/file/hooks/pre_update.py

@@ -0,0 +1,24 @@
+def pre_update(self):  # type: ignore[no-untyped-def]
+    """
+    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'')
+
+
+async def apre_update(self):  # type: ignore[no-untyped-def]
+    """
+    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'')