amsdal 0.2.5__cp312-cp312-win_amd64.whl

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

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import BinaryIO
+
+
+@classmethod  # type: ignore[misc, no-untyped-def]
+def from_file(
+    cls,
+    file_or_path: Path | BinaryIO,
+) -> 'File':  # type: ignore[name-defined]  # noqa: F821
+    """
+    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)

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

@@ -0,0 +1,13 @@
+@property  # type: ignore[misc]
+def mimetype(self) -> str | None:  # type: ignore[no-untyped-def]
+    """
+    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]

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

@@ -0,0 +1,6 @@
+def __str__(self) -> str:  # type: ignore[no-untyped-def] # noqa: N807
+    return repr(self)
+
+
+def __repr__(self) -> str:  # type: ignore[no-untyped-def] # noqa: N807
+    return f'File<{self.filename}>({self.size or len(self.data) or 0} bytes)'

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

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import BinaryIO
+
+
+def to_file(self, file_or_path: Path | BinaryIO) -> None:  # type: ignore[no-untyped-def]
+    """
+    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/schemas/core/file/properties/validate_data.py

@@ -0,0 +1,32 @@
+import base64
+
+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
+    """
+    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

amsdal/schemas/core/fixture/model.json

@@ -0,0 +1,35 @@
+{
+  "title": "Fixture",
+  "type": "object",
+  "properties": {
+    "class_name": {
+      "title": "Class Name",
+      "type": "string"
+    },
+    "order": {
+      "title": "Order",
+      "type": "number"
+    },
+    "external_id": {
+      "title": "External ID",
+      "type": "string"
+    },
+    "data": {
+      "title": "Data",
+      "type": "dictionary",
+      "items": {
+        "key": {"type": "string"},
+        "value": {"type": "anything"}
+      }
+    }
+  },
+  "required": [
+    "data",
+    "external_id"
+  ],
+  "unique": [
+    [
+      "external_id"
+    ]
+  ]
+}

amsdal/schemas/core/option/model.json

@@ -0,0 +1,19 @@
+{
+  "title": "Option",
+  "type": "object",
+  "properties": {
+    "key": {
+      "title": "Key",
+      "type": "string"
+    },
+    "value": {
+      "title": "Value Type",
+      "type": "string"
+    }
+  },
+  "required": [
+    "key",
+    "value"
+  ],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/core/validator/model.json

@@ -0,0 +1,19 @@
+{
+  "title": "Validator",
+  "type": "object",
+  "properties": {
+    "name": {
+      "title": "Validator Name",
+      "type": "string"
+    },
+    "data": {
+      "title": "Validator Data",
+      "type": "anything"
+    }
+  },
+  "required": [
+    "name",
+    "data"
+  ],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/manager.py

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

amsdal/schemas/manager.pyi

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

amsdal/schemas/types/anything/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Anything",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/array/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Array",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/binary/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Binary",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/boolean/model.json

@@ -0,0 +1,17 @@
+{
+  "title": "Boolean",
+  "type": "object",
+  "options": [
+    {
+      "key": "true",
+      "value": true
+    },
+    {
+      "key": "false",
+      "value": false
+    }
+  ],
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/date/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Date",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/datetime/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Datetime",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/dictionary/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "Dictionary",
+  "type": "object",
+  "default": null,
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/number/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "Number",
+  "type": "object",
+  "default": null,
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/object/model.json

@@ -0,0 +1,53 @@
+{
+  "title": "Object",
+  "type": "object",
+  "default": null,
+  "properties": {
+    "title": {
+      "title": "Title",
+      "type": "string"
+    },
+    "type": {
+      "title": "Type",
+      "type": "string"
+    },
+    "default": {
+      "title": "Default",
+      "type": "anything"
+    },
+    "properties": {
+      "title": "Properties",
+      "type": "dictionary",
+      "items": {
+        "key": {"type": "string"},
+        "value": {"type": "anything"}
+      }
+    },
+    "required": {
+      "title": "Required",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "unique": {
+      "title": "Unique Fields",
+      "type": "array",
+      "items": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "custom_code": {
+      "title": "Custom Code",
+      "type": "string"
+    },
+    "meta_class": {
+      "title": "Meta Class",
+      "type": "string"
+    }
+  },
+  "required": []
+}

amsdal/schemas/types/string/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "String",
+  "type": "object",
+  "default": "",
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/services/transaction_execution.pyi

@@ -0,0 +1,76 @@
+import ast
+from _typeshed import Incomplete
+from amsdal.configs.main import settings as settings
+from amsdal.errors import TransactionNotFoundError as TransactionNotFoundError
+from amsdal_utils.utils.singleton import Singleton
+from collections.abc import Callable as Callable, Generator
+from pathlib import Path
+from typing import Any
+
+logger: Incomplete
+
+def is_transaction(statement: ast.AST) -> bool:
+    """
+    Determines if a given AST statement is a transaction function.
+
+    This function checks if the provided AST statement is an asynchronous or synchronous function
+    definition that is decorated with the `transaction` decorator.
+
+    Args:
+        statement (ast.AST): The AST statement to check.
+
+    Returns:
+        bool: True if the statement is a transaction function, False otherwise.
+    """
+
+class TransactionExecutionService(metaclass=Singleton):
+    """
+    Service for executing transactions.
+
+    This class provides methods to execute transactions, load transaction functions,
+    and handle asynchronous transactions. It ensures that transactions are executed
+    with the correct arguments and handles any necessary preprocessing of arguments.
+    """
+    _transactions: Incomplete
+    def __init__(self) -> None: ...
+    def execute_transaction(self, transaction_name: str, args: dict[str, Any], *, load_references: bool = True) -> Any:
+        """
+        Executes a transaction with the given name and arguments.
+
+        This method retrieves the transaction function by its name, processes the arguments,
+        and executes the transaction. It handles both synchronous and asynchronous transactions
+        and performs necessary preprocessing of arguments, such as loading references.
+
+        Args:
+            transaction_name (str): The name of the transaction to execute.
+            args (dict[str, Any]): The arguments to pass to the transaction function.
+            load_references (bool, optional): Whether to load references in the arguments. Defaults to True.
+
+        Returns:
+            Any: The result of the transaction execution.
+        """
+    def get_transaction_func(self, transaction_name: str) -> Callable[..., Any]:
+        """
+        Retrieves the transaction function by its name.
+
+        This method checks if the transaction function is already loaded in the `_transactions` dictionary.
+        If not, it attempts to load the transaction function from the available transaction definitions.
+
+        Args:
+            transaction_name (str): The name of the transaction function to retrieve.
+
+        Returns:
+            Callable[..., Any]: The transaction function corresponding to the given name.
+
+        Raises:
+            TransactionNotFoundError: If the transaction function with the specified name is not found.
+        """
+    @staticmethod
+    def _run_async_transaction(transaction_func: Callable[..., Any], args: dict[str, Any]) -> Any: ...
+    def _load_transaction(self, transaction_name: str) -> Callable[..., Any]: ...
+    @classmethod
+    def _get_transaction_definitions(cls) -> Generator[tuple[ast.FunctionDef | ast.AsyncFunctionDef, Path], None, None]: ...
+    @classmethod
+    def _iterate_module(cls, module_path: Path) -> Generator[tuple[ast.FunctionDef | ast.AsyncFunctionDef, Path], None, None]: ...
+    @classmethod
+    def _iterate_file(cls, file_path: Path) -> Generator[tuple[ast.FunctionDef | ast.AsyncFunctionDef, Path], None, None]: ...

amsdal/utils/contrib_paths.py

@@ -0,0 +1,23 @@
+from collections.abc import Generator
+from importlib import import_module
+from pathlib import Path
+
+
+def get_contrib_schemas_paths() -> Generator[Path, None, None]:
+    """
+    Retrieves paths to contribution schemas.
+
+    This function iterates over the configured contributions in the settings and yields
+    the paths to the 'models' directories for each contribution.
+
+    Returns:
+        Generator[Path, None, None]: A generator that yields paths to the 'models' directories
+        of the configured contributions.
+    """
+    from amsdal.configs.main import settings
+
+    for contrib in settings.CONTRIB:
+        module_name, *_ = contrib.rsplit('.', 2)
+        module = import_module(module_name)
+
+        yield Path(module.__file__).parent / 'models'  # type: ignore[arg-type]

amsdal/utils/contrib_paths.pyi

@@ -0,0 +1,14 @@
+from collections.abc import Generator
+from pathlib import Path
+
+def get_contrib_schemas_paths() -> Generator[Path, None, None]:
+    """
+    Retrieves paths to contribution schemas.
+
+    This function iterates over the configured contributions in the settings and yields
+    the paths to the 'models' directories for each contribution.
+
+    Returns:
+        Generator[Path, None, None]: A generator that yields paths to the 'models' directories
+        of the configured contributions.
+    """

amsdal/utils/tests/enums.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class DbExecutionType(str, Enum):
+    lakehouse_only = 'lakehouse_only'
+    include_state_db = 'include_state_db'
+
+
+class StateOption(str, Enum):
+    sqlite = 'sqlite'
+    postgres = 'postgres'
+
+
+class LakehouseOption(str, Enum):
+    postgres = 'postgres'
+    postgres_immutable = 'postgres-immutable'
+    sqlite = 'sqlite'
+    sqlite_immutable = 'sqlite-immutable'