amsdal 0.3.1__cp312-cp312-macosx_10_13_universal2.whl → 0.3.3__cp312-cp312-macosx_10_13_universal2.whl

amsdal/fixtures/manager.pyi

@@ -116,3 +116,105 @@ class FixturesManager:
             None
         """
     def _process_file_fixture(self, file_path: Path, file_key: str) -> None: ...
+
+class AsyncFixturesManager:
+    """
+    Manager class for handling fixture data.
+
+    This class is responsible for loading, processing, and applying fixture data
+    to the database. It supports nested object construction, data processing,
+    and file fixture handling.
+    """
+    fixtures_path: Incomplete
+    fixtures: Incomplete
+    _created_cache: Incomplete
+    data_to_process: Incomplete
+    _class_manager: Incomplete
+    _config_manager: Incomplete
+    _schema_manager: Incomplete
+    def __init__(self, fixtures_path: Path, class_manager: ClassManager, config_manager: AmsdalConfigManager, schema_manager: SchemaManager) -> None: ...
+    def load_fixtures(self) -> None:
+        """
+        Loads fixture data from the specified path.
+
+        This method reads fixture data from a JSON file located at the `fixtures_path`.
+        It populates the `fixtures` dictionary with the loaded data, where each fixture
+        is indexed by its external ID.
+
+        Returns:
+            None
+        """
+    def construct_nested_object(self, external_id: Any) -> Any:
+        """
+        Constructs a nested object reference from the given external ID.
+
+        This method takes an external ID and constructs a nested object reference
+        dictionary. If the external ID is a dictionary containing an '_object_id' key,
+        it extracts the ID. If the external ID is not a string or integer, it returns
+        the external ID as is.
+
+        Args:
+            external_id (Any): The external ID to construct the nested object reference from.
+
+        Returns:
+            Any: A dictionary representing the nested object reference or the original
+            external ID if it is not a string or integer.
+        """
+    def _process_object_data(self, model_properties: dict[str, PropertyData], data: dict[str, Any]) -> dict[str, Any]: ...
+    def _process_object_value(self, field_configuration: PropertyData | DictSchema | TypeData, value: Any) -> Any: ...
+    async def process_fixture_object_data(self, class_name: str, external_id: str, data: dict[str, Any]) -> None:
+        """
+        Processes and saves fixture object data to the database.
+
+        This method takes the class name, external ID, and data dictionary of a fixture object,
+        processes the data according to the class schema, and saves the object to the database.
+        If the object already exists, it updates the existing object with the new data.
+
+        Args:
+            class_name (str): The name of the class to which the fixture object belongs.
+            external_id (str): The external ID of the fixture object.
+            data (dict[str, Any]): The data dictionary of the fixture object.
+
+        Returns:
+            None
+        """
+    async def process_fixture(self, fixture: dict[str, Any]) -> None:
+        """
+        Processes a single fixture and adds it to the processing queue.
+
+        This method takes a fixture dictionary, checks if the fixture already exists in the database,
+        and either updates the existing fixture or creates a new one. It then adds the fixture data
+        to the processing queue for further processing.
+
+        Args:
+            fixture (dict[str, Any]): The fixture dictionary containing the external ID, class name,
+            and data of the fixture.
+
+        Returns:
+            None
+        """
+    async def apply_fixtures(self) -> None:
+        """
+        Applies all loaded fixtures to the database.
+
+        This method processes each fixture in the `fixtures` dictionary in the order
+        specified by their 'order' value. It calls the `process_fixture` method for
+        each fixture and then processes the data in the processing queue.
+
+        Returns:
+            None
+        """
+    async def _process_data(self) -> None: ...
+    async def apply_file_fixtures(self) -> None:
+        """
+        Applies file fixtures from the specified directory.
+
+        This method processes file fixtures located in the 'files' directory adjacent to the
+        `fixtures_path`. It iterates through each file, reads its content, and processes it
+        as a fixture. If the file fixture already exists in the database, it updates the
+        existing fixture; otherwise, it creates a new one.
+
+        Returns:
+            None
+        """
+    async def _process_file_fixture(self, file_path: Path, file_key: str) -> None: ...

amsdal/manager.pyi

@@ -4,7 +4,7 @@ from amsdal.cloud.services.auth.manager import AuthManager as AuthManager
 from amsdal.cloud.services.auth.signup_service import SignupService as SignupService
 from amsdal.configs.main import settings as settings
 from amsdal.errors import AmsdalAuthenticationError as AmsdalAuthenticationError, AmsdalMissingCredentialsError as AmsdalMissingCredentialsError, AmsdalRuntimeError as AmsdalRuntimeError, AmsdalSignupError as AmsdalSignupError
-from amsdal.fixtures.manager import FixturesManager as FixturesManager
+from amsdal.fixtures.manager import AsyncFixturesManager as AsyncFixturesManager, FixturesManager as FixturesManager
 from amsdal.mixins.build_mixin import BuildMixin as BuildMixin
 from amsdal.mixins.class_versions_mixin import ClassVersionsMixin as ClassVersionsMixin
 from amsdal.schemas.manager import SchemaManager as SchemaManager
@@ -181,3 +181,172 @@ class AmsdalManager(BuildMixin, ClassVersionsMixin, metaclass=Singleton):
         Returns:
             None
         """
+
+class AsyncAmsdalManager(BuildMixin, ClassVersionsMixin, metaclass=Singleton):
+    """
+    Manages the AMSDAL framework components and operations.
+
+    This class is responsible for initializing, setting up, and managing various components
+    of the AMSDAL framework, including connections, data management, schema management,
+    and authentication. It also provides methods for building and tearing down the framework.
+    """
+    _class_manager: ClassManager
+    _config_manager: Incomplete
+    _config: Incomplete
+    _data_application: Incomplete
+    _is_setup: bool
+    __is_authenticated: bool
+    _schema_manager: Incomplete
+    _metadata_manager: Incomplete
+    _auth_manager: Incomplete
+    def __init__(self, *, raise_on_new_signup: bool = False) -> None:
+        """
+        Initializes all sub managers. Reads the configuration.
+
+        Returns:
+            None
+        """
+    @property
+    def is_setup(self) -> bool: ...
+    @property
+    def is_authenticated(self) -> bool:
+        """
+        Indicates if the AMSDAL license authentication process has been passed.
+
+        This property returns a boolean value indicating whether the AMSDAL license
+        authentication process has been successfully completed.
+
+        Returns:
+            bool: True if authenticated, False otherwise.
+        """
+    def pre_setup(self) -> None:
+        """
+        Initiates models root path and adds it into sys.path.
+
+        This method initializes the class manager and sets up the models root path
+        as specified in the settings. It ensures that the models root path is added
+        to the system path for proper module resolution.
+
+        Returns:
+            None
+        """
+    async def setup(self) -> None:
+        """
+        Initiates models root path and the connections.
+
+        This method sets up the AMSDAL framework by initializing the models root path and
+        establishing connections. It ensures that the setup process is only performed once.
+
+        Raises:
+            AmsdalRuntimeError: If the AMSDAL manager is already set up.
+
+        Returns:
+            None
+        """
+    async def post_setup(self) -> None:
+        """
+        Registers internal classes and prepares connections (creates internal tables).
+        """
+    def build(self, source_models_path: Path, source_transactions_path: Path, source_static_files_path: Path, source_fixtures_path: Path, source_migrations_path: Path) -> None:
+        """
+        Builds the necessary components for the Amsdal framework.
+
+        This method is used to build the necessary components for the Amsdal framework.
+        It takes five parameters which are all of type `Path`.
+        These parameters represent the paths to the directories where the corresponding components are located.
+
+        Args:
+            source_models_path (Path): Path to the directory where the source models are located.
+            source_transactions_path (Path): Path to the directory where the source transactions are located.
+            source_static_files_path (Path): Path to the directory where the source static files are located.
+            source_fixtures_path (Path): Path to the directory where the source fixtures are located.
+            source_migrations_path (Path): Path to the directory where the source migrations are located.
+
+        Returns:
+            None
+
+        The method performs the following build steps in order:
+        - Builds the models from the `source_models_path` by calling the `build_models` method.
+        - Builds the transactions from the `source_transactions_path` by calling the `build_transactions` method.
+        - Builds the static files from the `source_static_files_path` by calling the `build_static_files` method.
+        - Builds the fixtures from the `source_fixtures_path` by calling the `build_fixtures` method.
+
+        Note:
+            This method is part of the `AmsdalManager` class which includes mixins for `BuildMixin`
+            and `ClassVersionsMixin`. It is intended to be used in the Amsdal framework for managing
+            and building components.
+        """
+    def migrate(self) -> None:
+        """
+        DEPRECATED: Check changes in the models and apply them to the database.
+
+        This method is deprecated and should not be used. It checks for changes in the models
+        and applies them to the database. Use `amsdal.migration.file_migration_generator.FileMigrationGenerator`
+            instead.
+
+        Raises:
+            DeprecationWarning: Always raised to indicate that this method is deprecated.
+
+        Returns:
+            None
+        """
+    def _check_auth(self) -> None: ...
+    @property
+    def cloud_actions_manager(self) -> CloudActionsManager:
+        """
+        Provides access to the CloudActionsManager.
+
+        This property checks if the AMSDAL manager is authenticated and then returns
+        an instance of the CloudActionsManager.
+
+        Returns:
+            CloudActionsManager: An instance of the CloudActionsManager.
+
+        Raises:
+            AmsdalAuthenticationError: If the AMSDAL manager is not authenticated.
+        """
+    def authenticate(self) -> None:
+        """
+        Run AMSDAL license authentication process.
+
+        This method runs the AMSDAL license authentication process and sets the
+        authentication status accordingly.
+
+        Returns:
+            None
+        """
+    async def apply_fixtures(self) -> None:
+        """
+        Loads and applies fixtures defined in your application.
+
+        This method loads the fixtures from the specified path and applies them to the
+        AMSDAL framework. It uses the `FixturesManager` to manage the loading and application
+        of the fixtures.
+
+        Returns:
+            None
+        """
+    def init_classes(self) -> None:
+        """
+        Initializes and imports classes based on the schema manager's class schemas.
+
+        This method iterates over the class schemas provided by the schema manager and imports
+        the classes into the class manager, excluding those of type `SchemaTypes.TYPE`.
+
+        Returns:
+            None
+        """
+    async def teardown(self) -> None:
+        """
+        Clean up everything on the application exit.
+
+        This method performs a cleanup of all components managed by the AMSDAL framework
+        when the application exits. It disconnects and invalidates connections, clears caches,
+        and resets the setup status.
+
+        Raises:
+            AmsdalRuntimeError: If the AMSDAL manager is not set up.
+
+        Returns:
+            None
+        """

amsdal/migration/executors/base.pyi

@@ -104,3 +104,15 @@ class BaseMigrationExecutor(ABC, metaclass=abc.ABCMeta):
         Returns:
             None
         """
+
+class AsyncBaseMigrationExecutor(BaseMigrationExecutor, metaclass=abc.ABCMeta):
+    async def flush_buffer(self) -> None:
+        """
+        Flushes the migration buffer.
+
+        This method clears all entries from the main migration buffer, effectively
+        resetting it for future migration operations.
+
+        Returns:
+            None
+        """

amsdal/migration/executors/default_executor.pyi

@@ -3,7 +3,7 @@ from _typeshed import Incomplete
 from amsdal.errors import MigrationsError as MigrationsError
 from amsdal.migration.base_migration_schemas import BaseMigrationSchemas as BaseMigrationSchemas
 from amsdal.migration.data_classes import Action as Action
-from amsdal.migration.executors.base import BaseMigrationExecutor as BaseMigrationExecutor
+from amsdal.migration.executors.base import AsyncBaseMigrationExecutor as AsyncBaseMigrationExecutor, BaseMigrationExecutor as BaseMigrationExecutor
 from amsdal_models.classes.model import Model
 from amsdal_utils.models.data_models.schema import ObjectSchema
 from amsdal_utils.models.enums import SchemaTypes, Versions
@@ -95,3 +95,90 @@ class DefaultMigrationExecutor(BaseMigrationExecutor):
         Returns:
             None
         """
+
+class DefaultAsyncMigrationExecutor(AsyncBaseMigrationExecutor):
+    """
+    Default implementation of the BaseMigrationExecutor for handling database schema migrations.
+
+    This class provides concrete implementations for creating, updating, and deleting classes
+    in the database schema. It also manages schema migration buffers and processes object schemas.
+    """
+    schemas: Incomplete
+    _table_schemas_manager: Incomplete
+    def __init__(self, schemas: BaseMigrationSchemas) -> None: ...
+    def create_class(self, schemas: BaseMigrationSchemas, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes) -> None:
+        """
+        Creates a class in the database schema.
+
+        This method registers a new class version if the schema type is `TYPE` and the class name
+            is not `BaseClasses.OBJECT`.
+        Otherwise, it buffers the class migration operation for further processing.
+
+        Args:
+            schemas (BaseMigrationSchemas): The migration schemas used for the operations.
+            class_name (str): The name of the class to be created.
+            object_schema (ObjectSchema): The schema of the object to be created.
+            schema_type (SchemaTypes): The type of the schema.
+
+        Returns:
+            None
+        """
+    def update_class(self, schemas: BaseMigrationSchemas, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes) -> None:
+        """
+        Buffers the class update operation.
+
+        This method appends the given class name, object schema, and schema type to both
+        the non-flushable buffer and the main buffer for further processing.
+
+        Args:
+            schemas (BaseMigrationSchemas): The migration schemas used for the operations.
+            class_name (str): The name of the class to be updated.
+            object_schema (ObjectSchema): The current object schema.
+            schema_type (SchemaTypes): The type of the schema.
+
+        Returns:
+            None
+        """
+    async def delete_class(self, schemas: BaseMigrationSchemas, class_name: str, schema_type: SchemaTypes) -> None:
+        """
+        Deletes a class from the database schema.
+
+        This method removes the specified class from the database schema and unregisters it from the migration schemas.
+
+        Args:
+            schemas (BaseMigrationSchemas): The migration schemas used for the operations.
+            class_name (str): The name of the class to be deleted.
+            schema_type (SchemaTypes): The type of the schema.
+
+        Returns:
+            None
+        """
+    async def flush_buffer(self) -> None:
+        """
+        Flushes the migration buffer and processes the buffered classes.
+
+        This method registers the buffered classes in the migration schemas, compiles the buffered classes,
+        and processes each class in the buffer to create tables, save class objects, and migrate historical data.
+        Finally, it clears the main migration buffer.
+
+        Returns:
+            None
+        """
+    async def _check_class(self, schema_reference: glue.SchemaReference, object_schema: ObjectSchema, base_class: type[Model]) -> Action: ...
+    async def _save_class(self, schema_reference: glue.SchemaReference, base_class: type[Model], object_schema: ObjectSchema, action: Action) -> dict[str, Any]: ...
+    async def _save_object_class_meta(self, base_class: type[Model], object_schema: ObjectSchema, schema_type: SchemaTypes) -> None: ...
+    async def _create_table(self, object_schema: ObjectSchema, class_version: str | Versions, using: str | None = None) -> None: ...
+    async def _migrate_historical_data(self, schemas: BaseMigrationSchemas, class_name: str, prior_version: str, new_version: str) -> None: ...
+    def _clean_data(self, model_class: type[Model], data: dict[str, Any]) -> dict[str, Any]: ...
+    def _process_object_schema(self, object_schema: ObjectSchema, class_name: str, buffer: list[tuple[str, ObjectSchema, SchemaTypes]]) -> ObjectSchema: ...
+    async def register_schemas(self) -> None:
+        """
+        Registers the schemas in the table schemas manager.
+
+        This method retrieves the object schemas from the database, processes them, and registers
+        them in the table schemas manager. It handles both `ClassObject` and `ClassObjectMeta` schemas,
+        and ensures that all necessary references are loaded and processed.
+
+        Returns:
+            None
+        """

amsdal/mixins/class_versions_mixin.pyi

@@ -1,6 +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() -> None: ...
+    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/schemas/core/file/hooks/pre_create.py

@@ -9,3 +9,16 @@ def pre_create(self) -> None:  # type: ignore[no-untyped-def]
         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

@@ -9,3 +9,16 @@ def pre_update(self):  # type: ignore[no-untyped-def]
         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'')

amsdal/services/transaction_execution.pyi

@@ -41,6 +41,22 @@ class TransactionExecutionService(metaclass=Singleton):
         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.
+        """
+    async def async_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.