amsdal 0.3.6__cp312-cp312-macosx_10_13_universal2.whl → 0.4.0__cp312-cp312-macosx_10_13_universal2.whl

amsdal/contrib/frontend_configs/models/frontent_config_control_action/properties/action_validate.py

@@ -1,33 +0,0 @@
-from pydantic import field_validator
-
-
-@field_validator('action', mode='after')  # type: ignore[misc]
-@classmethod
-def validate_action(cls, v: str) -> str:  # type: ignore[no-untyped-def] # noqa: ARG001
-    """
-    Validates the action string to ensure it is one of the allowed values.
-
-    This method checks if the action string starts with 'navigate::' or is one of the predefined
-    actions. If the action string is invalid, it raises a ValueError.
-
-    Args:
-        cls: The class this method is attached to.
-        v (str): The action string to validate.
-
-    Returns:
-        str: The validated action string.
-
-    Raises:
-        ValueError: If the action string is not valid.
-    """
-    if not v.startswith('navigate::') and v not in [
-        'goPrev',
-        'goNext',
-        'goNextWithSubmit',
-        'submit',
-        'submitWithDataLayer',
-    ]:
-        msg = 'Action must be one of: goPrev, goNext, goNextWithSubmit, submit, submitWithDataLayer, navigate::{string}'
-        raise ValueError(msg)
-
-    return v

amsdal/migration/base_migration_schemas.pyi

@@ -1,119 +0,0 @@
-import abc
-from abc import ABC, abstractmethod
-from amsdal.configs.constants import BASE_DIR as BASE_DIR
-from amsdal_models.classes.model import Model
-from amsdal_utils.models.data_models.core import DictSchema, LegacyDictSchema, TypeData as TypeData
-from amsdal_utils.models.data_models.schema import ObjectSchema as ObjectSchema, PropertyData as PropertyData
-from amsdal_utils.models.enums import SchemaTypes as SchemaTypes, Versions
-from pathlib import Path
-
-class BaseMigrationSchemas(ABC, metaclass=abc.ABCMeta):
-    """
-    Abstract base class for migration schemas.
-
-    This class provides the interface for managing and compiling database schema migrations.
-    It includes methods for registering, unregistering, and compiling classes, as well as
-    managing class versions.
-    """
-    _classes: dict[str, type[Model]]
-    _classes_versions: dict[str, dict[str, type[Model]]]
-    _buffered_classes: list[tuple[str, ObjectSchema, SchemaTypes]]
-    def __init__(self) -> None: ...
-    def get_model(self, name: str) -> type[Model]:
-        """
-        Retrieves the model type for the given class name.
-
-        Args:
-            name (str): The name of the class whose model type is to be retrieved.
-
-        Returns:
-            type[Model]: The model type associated with the given class name.
-        """
-    @abstractmethod
-    def register_model(self, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes, class_version: str | Versions = ...) -> None: ...
-    @abstractmethod
-    def unregister_model(self, class_name: str) -> None: ...
-    @abstractmethod
-    def compile_buffered_classes(self) -> None: ...
-    @staticmethod
-    def register_model_version(class_name: str, class_version: str | Versions) -> None:
-        """
-        Registers a specific version of a model class.
-
-        This method registers a specific version of a model class using the ClassVersionManager.
-
-        Args:
-            class_name (str): The name of the class to register the version for.
-            class_version (str | Versions): The version of the class to be registered.
-
-        Returns:
-            None
-        """
-
-class DefaultMigrationSchemas(BaseMigrationSchemas):
-    """
-    Default implementation of the BaseMigrationSchemas.
-
-    This class provides the default implementation for managing and compiling database schema migrations.
-    It includes methods for registering, unregistering, and compiling classes, as well as managing class versions.
-
-    Attributes:
-        model_class_template_layout (Path): Path to the model class layout template.
-        model_class_template (Path): Path to the model class template.
-        dict_validator_template (Path): Path to the dictionary validator template.
-        options_validator_template (Path): Path to the options validator template.
-    """
-    model_class_template_layout: Path
-    model_class_template: Path
-    dict_validator_template: Path
-    options_validator_template: Path
-    def register_model(self, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes, class_version: str | Versions = ...) -> None:
-        """
-        Registers a model class for migration.
-
-        This method registers a model class for migration by adding it to the buffered classes
-        and registering its latest version.
-
-        Args:
-            class_name (str): The name of the class to be registered.
-            object_schema (ObjectSchema): The schema of the object to be registered.
-            schema_type (SchemaTypes): The type of the schema.
-
-        Returns:
-            None
-        """
-    def compile_buffered_classes(self) -> None:
-        """
-        Compiles all buffered classes for migration.
-
-        This method compiles all classes that have been buffered for migration and updates the
-        internal class dictionary with the compiled class types. It clears the buffer after
-        compilation.
-
-        Returns:
-            None
-        """
-    def unregister_model(self, class_name: str) -> None:
-        """
-        Unregisters a model class from the migration schemas.
-
-        This method removes the specified model class from the internal class dictionary,
-        effectively unregistering it from the migration schemas.
-
-        Args:
-            class_name (str): The name of the class to be unregistered.
-
-        Returns:
-            None
-        """
-    def _compile_buffered_classes(self) -> list[tuple[str, type[Model]]]: ...
-    def _build_class_source(self, class_name: str, schema: ObjectSchema, schema_type: SchemaTypes) -> tuple[str, str]: ...
-    @staticmethod
-    def _resolve_class_inheritance(schema: ObjectSchema) -> str: ...
-    @staticmethod
-    def _process_custom_code(custom_code: str | None) -> tuple[str, str]: ...
-    def _render_property(self, name: str, property_schema: PropertyData, required: list[str]) -> str: ...
-    def _render_type_annotation(self, type_: str, items: TypeData | DictSchema | LegacyDictSchema | None) -> str: ...
-    def _render_validators(self, schema: ObjectSchema) -> list[str]: ...
-    def _get_all_types(self, type_: str, items: TypeData | DictSchema | LegacyDictSchema | None) -> set[str]: ...
-    def _is_reference(self, type_: str) -> bool: ...

amsdal/migration/data_classes.pyi

@@ -1,165 +0,0 @@
-from amsdal_models.classes.model import Model
-from amsdal_utils.models.data_models.address import Address as Address
-from amsdal_utils.models.data_models.schema import ObjectSchema as ObjectSchema, PropertyData as PropertyData
-from amsdal_utils.models.enums import SchemaTypes as SchemaTypes
-from dataclasses import dataclass
-from enum import Enum
-from pathlib import Path
-
-class Action(str, Enum):
-    """
-    Enumeration for different types of actions.
-
-    Attributes:
-        CREATED (str): Represents a created action.
-        UPDATED (str): Represents an updated action.
-        NO_ACTION (str): Represents no action.
-    """
-    CREATE = 'CREATE'
-    UPDATE = 'UPDATE'
-    NO_ACTION = 'NO_ACTION'
-
-@dataclass
-class ClassSaveResult:
-    """
-    Data class representing the result of a class save operation.
-
-    Attributes:
-        action (Action): The action performed during the save operation.
-        instance (Model): The instance of the model that was saved.
-    """
-    action: Action
-    instance: Model
-
-@dataclass
-class ClassUpdateResult:
-    """
-    Data class representing the result of a class update operation.
-
-    Attributes:
-        is_updated (bool): Indicates whether the class was updated.
-        class_instance (Model): The instance of the model that was updated.
-    """
-    is_updated: bool
-    class_instance: Model
-
-@dataclass
-class MigrateResult:
-    """
-    Data class representing the result of a migration operation.
-
-    Attributes:
-        class_instance (Model): The instance of the model that was migrated.
-        is_table_created (bool): Indicates whether the table was created during the migration.
-        is_data_migrated (bool): Indicates whether the data was migrated.
-    """
-    class_instance: Model
-    is_table_created: bool
-    is_data_migrated: bool
-
-class ModuleTypes(str, Enum):
-    """
-    Enumeration for different types of modules.
-
-    Attributes:
-        APP (str): Represents an application module.
-        CORE (str): Represents a core module.
-        CONTRIB (str): Represents a contributed module.
-    """
-    APP = 'APP'
-    CORE = 'CORE'
-    CONTRIB = 'CONTRIB'
-
-@dataclass
-class MigrationFile:
-    """
-    Data class representing a migration file.
-
-    Attributes:
-        path (Path): The file path of the migration.
-        type (ModuleTypes): The type of module the migration belongs to.
-        number (int): The migration number.
-        module (str | None): The module name, if applicable.
-        applied_at (float | None): The timestamp when the migration was applied.
-        stored_address (Address | None): The stored address associated with the migration.
-    """
-    path: Path
-    type: ModuleTypes
-    number: int
-    module: str | None = ...
-    applied_at: float | None = ...
-    stored_address: Address | None = ...
-    @property
-    def is_initial(self) -> bool:
-        """
-        Indicates whether this migration is the initial migration.
-
-        Returns:
-            bool: True if this is the initial migration, False otherwise.
-        """
-
-@dataclass
-class ClassSchema:
-    """
-    Data class representing a class schema.
-
-    Attributes:
-        object_schema (ObjectSchema): The object schema associated with the class.
-        type (ModuleTypes): The type of module the class belongs to.
-    """
-    object_schema: ObjectSchema
-    type: ModuleTypes
-
-class OperationTypes(str, Enum):
-    """
-    Enumeration for different types of operations.
-
-    Attributes:
-        CREATE_CLASS (str): Represents the operation to create a class.
-        UPDATE_CLASS (str): Represents the operation to update a class.
-        DELETE_CLASS (str): Represents the operation to delete a class.
-    """
-    CREATE_CLASS = 'CREATE_CLASS'
-    UPDATE_CLASS = 'UPDATE_CLASS'
-    DELETE_CLASS = 'DELETE_CLASS'
-
-@dataclass
-class MigrateOperation:
-    """
-    Data class representing a migration operation.
-
-    Attributes:
-        type (OperationTypes): The type of operation being performed.
-        class_name (str): The name of the class involved in the migration.
-        schema_type (SchemaTypes): The type of schema associated with the migration.
-        old_schema (ObjectSchema | PropertyData | None): The old schema before the migration, if applicable.
-        new_schema (ObjectSchema | PropertyData | None): The new schema after the migration, if applicable.
-    """
-    type: OperationTypes
-    class_name: str
-    schema_type: SchemaTypes
-    old_schema: ObjectSchema | PropertyData | None = ...
-    new_schema: ObjectSchema | PropertyData | None = ...
-
-class MigrationDirection(str, Enum):
-    """
-    Enumeration for the direction of a migration.
-
-    Attributes:
-        FORWARD (str): Represents a forward migration.
-        BACKWARD (str): Represents a backward migration.
-    """
-    FORWARD = 'forward'
-    BACKWARD = 'backward'
-
-@dataclass
-class MigrationResult:
-    """
-    Data class representing the result of a migration.
-
-    Attributes:
-        direction (MigrationDirection): The direction of the migration.
-        migration (MigrationFile): The migration file associated with the migration.
-    """
-    direction: MigrationDirection
-    migration: MigrationFile

amsdal/migration/executors/base.pyi

@@ -1,117 +0,0 @@
-import abc
-from abc import ABC, abstractmethod
-from amsdal.migration.base_migration_schemas import BaseMigrationSchemas as BaseMigrationSchemas
-from amsdal_utils.models.data_models.schema import ObjectSchema as ObjectSchema
-from amsdal_utils.models.enums import SchemaTypes as SchemaTypes
-from pydantic import BaseModel
-
-class FieldDescription(BaseModel):
-    """
-    Represents a description of a field in a database schema.
-
-    This class holds information about a field, including its name, ID, type,
-    and whether it has been marked as deleted.
-
-    Attributes:
-        field_name (str): The name of the field.
-        field_id (str): The unique identifier of the field.
-        field_type (str): The type of the field.
-        is_deleted (bool): Indicates whether the field is marked as deleted.
-    """
-    field_name: str
-    field_id: str
-    field_type: str
-    is_deleted: bool
-
-def _schema_to_table_description(schema: ObjectSchema | None) -> dict[str, str]: ...
-def _compare_schemas(previous_scheme: dict[str, str], new_scheme: dict[str, str]) -> list[tuple[str, str, str]]: ...
-def _id_for_column(field_name: str, iteration: str | int) -> str: ...
-def _new_table_schemas(previous_scheme: ObjectSchema | None, new_scheme: ObjectSchema, iteration: int, existing_table_structure: list[FieldDescription]) -> None: ...
-
-class BaseMigrationExecutor(ABC, metaclass=abc.ABCMeta):
-    """
-    Abstract base class for executing migration operations on database schemas.
-
-    This class provides methods for creating, updating, and deleting classes in the database schema.
-    It also manages schema migration buffers and generates full object schemas based on the migration history.
-    """
-    schemas: BaseMigrationSchemas
-    _buffer: list[tuple[str, ObjectSchema, SchemaTypes]]
-    _non_flushable_buffer: list[tuple[str, ObjectSchema, SchemaTypes]]
-    def __init__(self) -> None: ...
-    def generate_full_object_schema(self, class_name: str, object_schema: ObjectSchema, buffer: list[tuple[str, ObjectSchema, SchemaTypes]]) -> list[FieldDescription]:
-        """
-        Generates the full object schema based on the migration history.
-
-        This method constructs the full object schema for a given class by iterating through
-        the migration history buffer and applying schema changes in sequence.
-
-        Args:
-            class_name (str): The name of the class for which the schema is being generated.
-            object_schema (ObjectSchema): The current object schema.
-            buffer (list[tuple[str, ObjectSchema, SchemaTypes]]): The migration history buffer.
-
-        Returns:
-            list[FieldDescription]: A list of field descriptions representing the full object schema.
-        """
-    @abstractmethod
-    def create_class(self, schemas: BaseMigrationSchemas, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes) -> None: ...
-    @abstractmethod
-    def update_class(self, schemas: BaseMigrationSchemas, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes) -> None: ...
-    @abstractmethod
-    def delete_class(self, schemas: BaseMigrationSchemas, class_name: str, schema_type: SchemaTypes) -> None: ...
-    def forward_schema(self, schemas: BaseMigrationSchemas, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes) -> None:
-        """
-        Forwards the schema to the non-flushable buffer.
-
-        This method appends the given class name, object schema, and schema type to the
-        non-flushable buffer for further processing.
-
-        Args:
-            schemas (BaseMigrationSchemas): The migration schemas used for the operations.
-            class_name (str): The name of the class for which the schema is being forwarded.
-            object_schema (ObjectSchema): The current object schema.
-            schema_type (SchemaTypes): The type of the schema.
-
-        Returns:
-            None
-        """
-    @staticmethod
-    def _resolve_base_class_name(class_name: str, meta_class: str) -> str: ...
-    def buffer_class_migration(self, class_name: str, object_schema: ObjectSchema, schema_type: SchemaTypes) -> None:
-        """
-        Buffers the class migration 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:
-            class_name (str): The name of the class for which the migration is being buffered.
-            object_schema (ObjectSchema): The current object schema.
-            schema_type (SchemaTypes): The type of the schema.
-
-        Returns:
-            None
-        """
-    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
-        """
-
-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

@@ -1,184 +0,0 @@
-import amsdal_glue as glue
-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 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
-from typing import Any
-
-class DefaultMigrationExecutor(BaseMigrationExecutor):
-    """
-    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
-        """
-    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
-        """
-    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
-        """
-    def _check_class(self, schema_reference: glue.SchemaReference, object_schema: ObjectSchema, base_class: type[Model]) -> Action: ...
-    def _save_class(self, schema_reference: glue.SchemaReference, base_class: type[Model], object_schema: ObjectSchema, action: Action) -> dict[str, Any]: ...
-    def _save_object_class_meta(self, base_class: type[Model], object_schema: ObjectSchema, schema_type: str) -> None: ...
-    def _create_table(self, object_schema: ObjectSchema, class_version: str | Versions, using: str | None = None) -> None: ...
-    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: ...
-    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
-        """
-
-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
-        """