amsdal 0.3.0__cp312-cp312-macosx_10_13_universal2.whl → 0.3.2__cp312-cp312-macosx_10_13_universal2.whl

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/utils/rollback/__init__.py

@@ -1,5 +1,7 @@
 import amsdal_glue as glue
+from amsdal_data.application import AsyncDataApplication
 from amsdal_data.application import DataApplication
+from amsdal_data.transactions.decorators import async_transaction
 from amsdal_data.transactions.decorators import transaction
 from amsdal_data.transactions.errors import AmsdalTransactionError
 from amsdal_models.classes.manager import ClassManager
@@ -198,3 +200,196 @@ def rollback_transaction(transaction_id: str) -> None:
 
     updated_at = metadatas_to_revert[0].data['updated_at']
     rollback_to_timestamp(updated_at)
+
+
+@async_transaction
+async def async_rollback_to_timestamp(timestamp: float) -> None:
+    """
+    Rollback the data to the given timestamp
+    Args:
+        timestamp (float): The timestamp to rollback the data to.
+    Returns:
+        None
+    """
+    class_manager = ClassManager()
+
+    lakehouse_connection = await (
+        AsyncDataApplication()._application.lakehouse_connection_manager.get_connection_pool('Company').get_connection()
+    )
+
+    metadatas_to_delete = await lakehouse_connection.query(
+        query=glue.QueryStatement(
+            table=glue.SchemaReference(name='Metadata', version=glue.Version.LATEST),
+            where=glue.Conditions(
+                glue.Condition(
+                    field=glue.FieldReference(field=glue.Field(name='updated_at'), table_name='Metadata'),
+                    lookup=glue.FieldLookup.GT,
+                    value=glue.Value(timestamp),
+                ),
+                glue.Condition(
+                    field=glue.FieldReference(field=glue.Field(name='prior_version'), table_name='Metadata'),
+                    lookup=glue.FieldLookup.ISNULL,
+                    value=glue.Value(True),
+                ),
+            ),
+        )
+    )
+
+    ids_to_ignore = [m.data['object_id'] for m in metadatas_to_delete]
+
+    metadatas_to_revert = await lakehouse_connection.query(
+        query=glue.QueryStatement(
+            table=glue.SchemaReference(name='Metadata', version=glue.Version.LATEST),
+            where=glue.Conditions(
+                glue.Condition(
+                    field=glue.FieldReference(field=glue.Field(name='updated_at'), table_name='Metadata'),
+                    lookup=glue.FieldLookup.GT,
+                    value=glue.Value(timestamp),
+                ),
+                glue.Condition(
+                    field=glue.FieldReference(field=glue.Field(name='prior_version'), table_name='Metadata'),
+                    lookup=glue.FieldLookup.ISNULL,
+                    value=glue.Value(False),
+                ),
+            ),
+        )
+    )
+
+    transaction_ids = {m.data['transaction']['ref']['object_id'] for m in metadatas_to_revert}
+    transaction_ids.update({m.data['transaction']['ref']['object_id'] for m in metadatas_to_delete})
+    ids_to_revert = [
+        (m.data['object_id'], m.data['class_schema_reference']['ref']['object_id'])
+        for m in metadatas_to_revert
+        if m.data['object_id'] not in ids_to_ignore
+    ]
+
+    if transaction_ids:
+        _conditions = []
+        for transaction_id in transaction_ids:
+            _parent_field = glue.Field(
+                name='transaction',
+                child=glue.Field(
+                    name='ref',
+                    child=glue.Field(name='object_id'),
+                ),
+            )
+            _parent_field.child.parent = _parent_field  # type: ignore[union-attr]
+            _parent_field.child.child.parent = _parent_field.child  # type: ignore[union-attr]
+            _conditions.append(
+                glue.Condition(
+                    field=glue.FieldReference(field=_parent_field, table_name='Metadata'),
+                    lookup=glue.FieldLookup.EQ,
+                    value=glue.Value(transaction_id),
+                )
+            )
+
+        conflict_metadata = await lakehouse_connection.query(
+            query=glue.QueryStatement(
+                table=glue.SchemaReference(name='Metadata', version=glue.Version.LATEST),
+                where=glue.Conditions(
+                    glue.Condition(
+                        field=glue.FieldReference(field=glue.Field(name='updated_at'), table_name='Metadata'),
+                        lookup=glue.FieldLookup.LTE,
+                        value=glue.Value(timestamp),
+                    ),
+                    glue.Conditions(*_conditions, connector=glue.FilterConnector.OR),
+                ),
+            )
+        )
+        if conflict_metadata:
+            msg = 'Cannot rollback to this timestamp because it will conflict with other transactions'
+            raise AmsdalTransactionError(msg)
+
+    for m in metadatas_to_delete:
+        class_name = m.data['class_schema_reference']['ref']['object_id']
+        schema_type = class_manager.resolve_schema_type(class_name)
+
+        model_class = class_manager.import_model_class(class_name, schema_type)
+        obj = await (
+            model_class.objects.filter(_address__object_id=m.data['object_id'])
+            .using(LAKEHOUSE_DB_ALIAS)
+            .latest()
+            .first()
+            .aexecute()
+        )
+
+        if obj and not (await obj.aget_metadata()).is_deleted:
+            await obj.adelete()
+
+    for object_id, class_name in ids_to_revert:
+        schema_type = class_manager.resolve_schema_type(class_name)
+        model_class = class_manager.import_model_class(class_name, schema_type)
+
+        obj = await (
+            model_class.objects.filter(_address__object_id=object_id)
+            .using(LAKEHOUSE_DB_ALIAS)
+            .latest()
+            .first()
+            .aexecute()
+        )
+        old_obj = await (
+            model_class.objects.filter(_address__object_id=object_id, _metadata__updated_at__lte=timestamp)
+            .using(LAKEHOUSE_DB_ALIAS)
+            .order_by('-_metadata__updated_at')
+            .first()
+            .aexecute()
+        )
+
+        if obj and old_obj:
+            for field, value in old_obj.model_dump().items():
+                setattr(obj, field, value)
+
+            await obj.asave()
+
+            if (await old_obj.aget_metadata()).is_deleted:
+                await obj.adelete()
+
+
+@async_transaction
+async def async_rollback_transaction(transaction_id: str) -> None:
+    """
+    Rollback the data to the point in time before the given transaction
+    Args:
+        transaction_id (str): The transaction ID to rollback the data to.
+    Returns:
+        None
+    """
+    lakehouse_connection = await (
+        AsyncDataApplication()._application.lakehouse_connection_manager.get_connection_pool('Company').get_connection()
+    )
+
+    _parent_field = glue.Field(
+        name='transaction',
+        child=glue.Field(
+            name='ref',
+            child=glue.Field(name='object_id'),
+        ),
+    )
+    _parent_field.child.parent = _parent_field  # type: ignore[union-attr]
+    _parent_field.child.child.parent = _parent_field.child  # type: ignore[union-attr]
+
+    metadatas_to_revert = await lakehouse_connection.query(
+        query=glue.QueryStatement(
+            table=glue.SchemaReference(name='Metadata', version=glue.Version.LATEST),
+            where=glue.Conditions(
+                glue.Condition(
+                    field=glue.FieldReference(field=_parent_field, table_name='Metadata'),
+                    lookup=glue.FieldLookup.EQ,
+                    value=glue.Value(transaction_id),
+                )
+            ),
+            order_by=[
+                glue.OrderByQuery(
+                    field=glue.FieldReference(field=glue.Field(name='updated_at'), table_name='Metadata'),
+                    direction=glue.OrderDirection.DESC,
+                )
+            ],
+        )
+    )
+
+    if not metadatas_to_revert:
+        msg = 'Transaction not found'
+        raise AmsdalTransactionError(msg)
+
+    updated_at = metadatas_to_revert[0].data['updated_at']
+    await async_rollback_to_timestamp(updated_at)  # type: ignore[misc]

amsdal/utils/rollback/__init__.pyi

@@ -14,3 +14,19 @@ def rollback_transaction(transaction_id: str) -> None:
     Returns:
         None
     """
+async def async_rollback_to_timestamp(timestamp: float) -> None:
+    """
+    Rollback the data to the given timestamp
+    Args:
+        timestamp (float): The timestamp to rollback the data to.
+    Returns:
+        None
+    """
+async def async_rollback_transaction(transaction_id: str) -> None:
+    """
+    Rollback the data to the point in time before the given transaction
+    Args:
+        transaction_id (str): The transaction ID to rollback the data to.
+    Returns:
+        None
+    """

{amsdal-0.3.0.dist-info → amsdal-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amsdal
-Version: 0.3.0
+Version: 0.3.2
 Summary: AMSDAL
 License: AMSDAL End User License Agreement
         
@@ -133,13 +133,15 @@ Requires-Dist: amsdal_utils==0.3.*
 Requires-Dist: amsdal_data[postgres-binary]==0.3.*
 Requires-Dist: amsdal_models==0.3.*
 Provides-Extra: cli
-Requires-Dist: amsdal-cli==0.2.*; extra == "cli"
+Requires-Dist: amsdal-cli==0.3.*; extra == "cli"
 Provides-Extra: server
-Requires-Dist: amsdal-server==0.2.*; extra == "server"
+Requires-Dist: amsdal-server==0.3.*; extra == "server"
 Provides-Extra: factory
 Requires-Dist: polyfactory==2.*; extra == "factory"
 Provides-Extra: celery
 Requires-Dist: celery==5.4.0; extra == "celery"
+Provides-Extra: aiosqlite
+Requires-Dist: aiosqlite>=0.20.0; extra == "aiosqlite"
 
 # AMSDAL