mpt-tool 5.0.0__py3-none-any.whl

mpt_tool/cli.py

@@ -0,0 +1,76 @@
+import logging
+from typing import Annotated
+
+import typer
+
+from mpt_tool.commands import CommandFactory, MigrateCommandValidator
+from mpt_tool.commands.errors import BadParameterError, CommandNotFoundError
+from mpt_tool.use_cases.errors import UseCaseError
+
+app = typer.Typer(help="MPT CLI - Migration tool for extensions.", no_args_is_help=True)
+
+
+@app.callback()
+def callback() -> None:
+    """MPT CLI - Migration tool for extensions."""
+
+
+@app.command("migrate")
+def migrate(  # noqa: WPS211
+    ctx: typer.Context,
+    data: Annotated[bool, typer.Option("--data", help="Run data migrations.")] = False,  # noqa: FBT002
+    schema: Annotated[bool, typer.Option("--schema", help="Run schema migrations.")] = False,  # noqa: FBT002
+    fake: Annotated[
+        str | None,
+        typer.Option(
+            "--fake",
+            help="Mark the migration provided as applied without running it",
+            metavar="MIGRATION_ID",
+        ),
+    ] = None,
+    new_data: Annotated[
+        str | None,
+        typer.Option(
+            "--new-data",
+            metavar="FILENAME",
+            help="Scaffold a new data migration script with the provided filename.",
+        ),
+    ] = None,
+    new_schema: Annotated[
+        str | None,
+        typer.Option(
+            "--new-schema",
+            metavar="FILENAME",
+            help="Scaffold a new schema migration script with the provided filename.",
+        ),
+    ] = None,
+    list: Annotated[bool, typer.Option("--list", help="List all migrations.")] = False,  # noqa: A002, FBT002
+) -> None:
+    """Migrate command."""
+    try:
+        MigrateCommandValidator.validate(ctx.params)
+    except BadParameterError as error:
+        raise typer.BadParameter(str(error), param_hint="migrate")
+
+    try:
+        command_instance = CommandFactory.get_instance(ctx.params)
+    except CommandNotFoundError:
+        raise typer.BadParameter("No valid param provided.", param_hint="migrate")
+
+    typer.echo(command_instance.start_message)
+    try:
+        command_instance.run()
+    except UseCaseError as error:
+        typer.secho(
+            f"Error running {command_instance.name} command: {error!s}",
+            fg=typer.colors.RED,
+        )
+        raise typer.Abort
+
+    typer.secho(command_instance.success_message, fg=typer.colors.GREEN)
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+    app()

mpt_tool/commands/__init__.py

@@ -0,0 +1,4 @@
+from mpt_tool.commands.factory import CommandFactory
+from mpt_tool.commands.validators import MigrateCommandValidator
+
+__all__ = ["CommandFactory", "MigrateCommandValidator"]

mpt_tool/commands/base.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+
+
+class BaseCommand(ABC):
+    """Base class for migration commands."""
+
+    @property
+    def name(self) -> str:
+        """The name of the command, used for CLI argument parsing."""
+        return self.__class__.__name__.replace("Command", "").lower()
+
+    @property
+    @abstractmethod
+    def start_message(self) -> str:
+        """Message to display before starting the migration."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def success_message(self) -> str:
+        """Message to display after the migration has finished."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def run(self) -> None:
+        """Executes the migration."""
+        raise NotImplementedError

mpt_tool/commands/data.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from mpt_tool.commands.base import BaseCommand
+from mpt_tool.enums import MigrationTypeEnum
+from mpt_tool.use_cases import RunMigrationsUseCase
+
+
+class DataCommand(BaseCommand):
+    """Runs all data migrations."""
+
+    @override
+    @property
+    def start_message(self) -> str:
+        return f"Running {MigrationTypeEnum.DATA} migrations..."
+
+    @override
+    @property
+    def success_message(self) -> str:
+        return "Migrations completed successfully."
+
+    @override
+    def run(self) -> None:
+        RunMigrationsUseCase().execute(MigrationTypeEnum.DATA)

mpt_tool/commands/errors.py

@@ -0,0 +1,9 @@
+from mpt_tool.errors import BaseError
+
+
+class BadParameterError(BaseError):
+    """Bad parameter error."""
+
+
+class CommandNotFoundError(BaseError):
+    """Command not found error."""

mpt_tool/commands/factory.py

@@ -0,0 +1,45 @@
+from typing import cast
+
+from mpt_tool.commands.base import (
+    BaseCommand,
+)
+from mpt_tool.commands.data import DataCommand
+from mpt_tool.commands.errors import CommandNotFoundError
+from mpt_tool.commands.fake import FakeCommand
+from mpt_tool.commands.list import ListCommand
+from mpt_tool.commands.new_data import NewDataCommand
+from mpt_tool.commands.new_schema import NewSchemaCommand
+from mpt_tool.commands.schema import SchemaCommand
+
+
+class CommandFactory:
+    """Command factory to create the correct command."""
+
+    @classmethod
+    def get_instance(cls, param_data: dict[str, bool | str | None]) -> BaseCommand:  # noqa: C901, WPS212
+        """Get the correct command instance based on the parameter data.
+
+        Args:
+            param_data: The parameter data.
+
+        Return:
+            The command instance.
+
+        Raises:
+            CommandNotFoundError: If no command is found.
+        """
+        match param_data:
+            case {"data": True}:
+                return DataCommand()
+            case {"schema": True}:
+                return SchemaCommand()
+            case {"fake": fake_value} if fake_value is not None:
+                return FakeCommand(migration_id=cast(str, fake_value))
+            case {"new_schema": new_schema_value} if new_schema_value is not None:
+                return NewSchemaCommand(migration_id=cast(str, new_schema_value))
+            case {"new_data": new_data_value} if new_data_value is not None:
+                return NewDataCommand(migration_id=cast(str, new_data_value))
+            case {"list": True}:
+                return ListCommand()
+            case _:
+                raise CommandNotFoundError("Command not found.")

mpt_tool/commands/fake.py

@@ -0,0 +1,26 @@
+from typing import override
+
+from mpt_tool.commands.base import BaseCommand
+from mpt_tool.use_cases import ApplyMigrationUseCase
+
+
+class FakeCommand(BaseCommand):
+    """Applies a migration without running it."""
+
+    def __init__(self, migration_id: str):
+        super().__init__()
+        self.migration_id = migration_id
+
+    @override
+    @property
+    def start_message(self) -> str:
+        return f"Running migration {self.migration_id} in fake mode."
+
+    @override
+    @property
+    def success_message(self) -> str:
+        return f"Migration {self.migration_id} applied successfully."
+
+    @override
+    def run(self) -> None:
+        ApplyMigrationUseCase().execute(migration_id=self.migration_id)

mpt_tool/commands/list.py

@@ -0,0 +1,33 @@
+from typing import override
+
+import typer
+from rich.console import Console
+
+from mpt_tool.commands.base import BaseCommand
+from mpt_tool.constants import CONSOLE_WIDTH
+from mpt_tool.renders import MigrationRender
+from mpt_tool.use_cases import ListMigrationsUseCase
+
+
+class ListCommand(BaseCommand):
+    """Lists all migrations."""
+
+    @override
+    @property
+    def start_message(self) -> str:
+        return "Listing migrations..."
+
+    @override
+    @property
+    def success_message(self) -> str:
+        return "Migrations listed successfully."
+
+    @override
+    def run(self) -> None:
+        migrations = ListMigrationsUseCase().execute()
+        if not migrations:
+            typer.echo("No migrations found.")
+            return
+
+        console = Console(width=CONSOLE_WIDTH)
+        console.print(MigrationRender(migration_items=migrations), overflow="fold")

mpt_tool/commands/new_data.py

@@ -0,0 +1,30 @@
+from typing import override
+
+import typer
+
+from mpt_tool.commands.base import BaseCommand
+from mpt_tool.enums import MigrationTypeEnum
+from mpt_tool.use_cases import NewMigrationUseCase
+
+
+class NewDataCommand(BaseCommand):
+    """Creates a new data migration file with the given id."""
+
+    def __init__(self, migration_id: str) -> None:
+        super().__init__()
+        self.migration_id = migration_id
+
+    @override
+    @property
+    def start_message(self) -> str:
+        return f"Scaffolding migration: {self.migration_id}."
+
+    @override
+    @property
+    def success_message(self) -> str:
+        return ""
+
+    @override
+    def run(self) -> None:
+        filename = NewMigrationUseCase().execute(MigrationTypeEnum.DATA, self.migration_id)
+        typer.echo(f"Migration file: {filename} has been created.")

mpt_tool/commands/new_schema.py

@@ -0,0 +1,30 @@
+from typing import override
+
+import typer
+
+from mpt_tool.commands.base import BaseCommand
+from mpt_tool.enums import MigrationTypeEnum
+from mpt_tool.use_cases import NewMigrationUseCase
+
+
+class NewSchemaCommand(BaseCommand):
+    """Creates a new schema migration file with the given id."""
+
+    def __init__(self, migration_id: str) -> None:
+        super().__init__()
+        self.migration_id = migration_id
+
+    @override
+    @property
+    def start_message(self) -> str:
+        return f"Scaffolding migration: {self.migration_id}."
+
+    @override
+    @property
+    def success_message(self) -> str:
+        return ""
+
+    @override
+    def run(self) -> None:
+        filename = NewMigrationUseCase().execute(MigrationTypeEnum.SCHEMA, self.migration_id)
+        typer.echo(f"Migration file: {filename} has been created.")

mpt_tool/commands/schema.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from mpt_tool.commands.base import BaseCommand
+from mpt_tool.enums import MigrationTypeEnum
+from mpt_tool.use_cases import RunMigrationsUseCase
+
+
+class SchemaCommand(BaseCommand):
+    """Runs all schema migrations."""
+
+    @override
+    @property
+    def start_message(self) -> str:
+        return f"Running {MigrationTypeEnum.SCHEMA} migrations..."
+
+    @override
+    @property
+    def success_message(self) -> str:
+        return f"{MigrationTypeEnum.SCHEMA} migrations applied successfully."
+
+    @override
+    def run(self) -> None:
+        RunMigrationsUseCase().execute(MigrationTypeEnum.SCHEMA)

mpt_tool/commands/validators.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from mpt_tool.commands.errors import BadParameterError
+
+
+class MigrateCommandValidator:
+    """Validator for the migrate command."""
+
+    @classmethod
+    def validate(cls, command_params: dict[str, Any]) -> None:
+        """Validate the migrate command parameters.
+
+        Args:
+            command_params: The migrate command parameters.
+
+        Raises:
+            BadParameterError: When none or more than one param is used
+        """
+        param_counts = sum(1 for param_value in command_params.values() if param_value)
+        if not param_counts:
+            raise BadParameterError("At least one param must be used.")
+
+        if param_counts > 1:
+            raise BadParameterError("Only one param can be used.")

mpt_tool/config.py

@@ -0,0 +1,22 @@
+import os
+
+
+def get_airtable_config(config_key: str) -> str | None:
+    """Get Airtable configuration."""
+    config = {
+        "api_key": os.getenv("AIRTABLE_API_KEY"),
+        "base_id": os.getenv("STORAGE_AIRTABLE_BASE_ID"),
+        "table_name": os.getenv("STORAGE_AIRTABLE_TABLE_NAME", "Migrations"),
+    }
+    return config.get(config_key)
+
+
+def get_mpt_config(config_key: str) -> str | None:
+    """Get MPT configuration."""
+    config = {"api_token": os.getenv("MPT_API_TOKEN"), "base_url": os.getenv("MPT_API_BASE_URL")}
+    return config.get(config_key)
+
+
+def get_storage_type() -> str:
+    """Get storage type."""
+    return os.getenv("STORAGE_TYPE", "local")

mpt_tool/constants.py

@@ -0,0 +1,4 @@
+CONSOLE_WIDTH: int = 200
+MAX_LEN_MIGRATION_ID: int = 125
+MIGRATION_FOLDER: str = "migrations"
+MIGRATION_STATE_FILE: str = ".migrations-state.json"

mpt_tool/enums.py

@@ -0,0 +1,41 @@
+from enum import StrEnum
+from typing import TYPE_CHECKING, Self
+
+if TYPE_CHECKING:
+    from mpt_tool.models import Migration
+
+
+class MigrationStatusEnum(StrEnum):
+    """Enumeration of migration status values."""
+
+    RUNNING = "running"
+    FAILED = "failed"
+    FAKE_APPLY = "faked"
+    APPLIED = "applied"
+    NOT_APPLIED = "not applied"
+
+    @classmethod
+    def from_state(cls, migration_state: "Migration | None") -> Self:
+        """Calculate migration status based on migration state."""
+        if migration_state is None:
+            return cls.NOT_APPLIED
+        if migration_state.started_at and migration_state.applied_at:
+            return cls.APPLIED
+        if migration_state.started_at and not migration_state.applied_at:
+            return cls.RUNNING
+        if migration_state.started_at is None and migration_state.applied_at:
+            return cls.FAKE_APPLY
+
+        return cls.FAILED
+
+
+class MigrationTypeEnum(StrEnum):
+    """Enumeration of migration types.
+
+    Attributes:
+        DATA: Represents a data migration.
+        SCHEMA: Represents a schema migration.
+    """
+
+    DATA = "data"
+    SCHEMA = "schema"

mpt_tool/errors.py

@@ -0,0 +1,9 @@
+from typing import override
+
+
+class BaseError(Exception):
+    """Base error."""
+
+    @override
+    def __init__(self, message: str):
+        super().__init__(message)

mpt_tool/managers/__init__.py

@@ -0,0 +1,5 @@
+from mpt_tool.managers.file_migration import FileMigrationManager
+from mpt_tool.managers.state.base import StateManager
+from mpt_tool.managers.state.factory import StateManagerFactory
+
+__all__ = ["FileMigrationManager", "StateManager", "StateManagerFactory"]

mpt_tool/managers/encoders.py

@@ -0,0 +1,15 @@
+import json
+from typing import Any, override
+
+from mpt_tool.models import Migration
+
+
+class StateJSONEncoder(json.JSONEncoder):
+    """JSON encoder for migration states."""
+
+    @override
+    def default(self, obj: object) -> Any:  # noqa: WPS110
+        if isinstance(obj, Migration):
+            return obj.to_dict()
+
+        return super().default(obj)

mpt_tool/managers/errors.py

@@ -0,0 +1,25 @@
+from mpt_tool.errors import BaseError
+
+
+class ManagerError(BaseError):
+    """Base error for all manager errors."""
+
+
+class CreateMigrationError(ManagerError):
+    """Error creating the migration file."""
+
+
+class InvalidStateError(ManagerError):
+    """Error loading invalid state."""
+
+
+class LoadMigrationError(ManagerError):
+    """Error loading migrations."""
+
+
+class MigrationFolderError(ManagerError):
+    """Error accessing migrations folder."""
+
+
+class StateNotFoundError(ManagerError):
+    """Error getting state from state file."""

mpt_tool/managers/file_migration.py

@@ -0,0 +1,132 @@
+import re
+from collections import Counter
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+from typing import cast
+
+from mpt_tool.constants import MIGRATION_FOLDER
+from mpt_tool.enums import MigrationTypeEnum
+from mpt_tool.managers.errors import CreateMigrationError, LoadMigrationError, MigrationFolderError
+from mpt_tool.migration.base import BaseMigration
+from mpt_tool.models import MigrationFile
+from mpt_tool.templates import MIGRATION_SCAFFOLDING_TEMPLATE
+
+
+class FileMigrationManager:
+    """Manages migration files."""
+
+    _migration_folder: Path = Path(MIGRATION_FOLDER)
+
+    @classmethod
+    def load_migration(cls, migration_file: MigrationFile) -> BaseMigration:
+        """Loads a migration instance from a migration file.
+
+        Args:
+            migration_file: The migration file to load.
+
+        Returns:
+            The migration instance.
+
+        Raise:
+            LoadMigrationError: If an error occurs during migration loading.
+        """
+        spec = spec_from_file_location(migration_file.name, migration_file.full_path)
+        if spec is None or spec.loader is None:
+            raise LoadMigrationError(f"Failed to load migration file: {migration_file.full_path}")
+
+        migration_module = module_from_spec(spec)
+        try:
+            spec.loader.exec_module(migration_module)
+        except ImportError as error:
+            raise LoadMigrationError(f"Failed to import migration module: {error!s}") from error
+
+        try:
+            migration_instance = cast(BaseMigration, migration_module.Migration())
+        except (TypeError, AttributeError) as error:
+            raise LoadMigrationError(f"Invalid migration: {error!s}") from error
+
+        return migration_instance
+
+    @classmethod
+    def new_migration(cls, file_suffix: str, migration_type: MigrationTypeEnum) -> MigrationFile:
+        """Creates a new migration file.
+
+        Args:
+            file_suffix: The suffix to use for the migration file name.
+            migration_type: The type of migration to create.
+
+        Return:
+            The newly created migration file.
+
+        Raises:
+            CreateMigrationError: If an error occurs during migration creation.
+        """
+        cls._migration_folder.mkdir(parents=True, exist_ok=True)
+        try:
+            migration_file = MigrationFile.new(migration_id=file_suffix, path=cls._migration_folder)
+        except ValueError as error:
+            raise CreateMigrationError(f"Invalid migration ID: {error}") from error
+
+        try:
+            migration_file.full_path.touch(exist_ok=False)
+        except FileExistsError as error:
+            raise CreateMigrationError(
+                f"File already exists: {migration_file.file_name}"
+            ) from error
+
+        migration_file.full_path.write_text(
+            encoding="utf-8",
+            data=MIGRATION_SCAFFOLDING_TEMPLATE.substitute(
+                migration_name="DataBaseMigration"
+                if migration_type == MigrationTypeEnum.DATA
+                else "SchemaBaseMigration"
+            ),
+        )
+        return migration_file
+
+    @classmethod
+    def retrieve_migration_files(cls) -> tuple[MigrationFile, ...]:
+        """Retrieves all migration files."""
+        return cls._get_migration_files()
+
+    @classmethod
+    def validate(cls) -> tuple[MigrationFile, ...]:
+        """Validates the migration folder and returns a tuple of migration files.
+
+        Returns:
+            The validated migration files.
+
+        Raises:
+             MigrationFolderError: If an error occurs during migration validation.
+        """
+        if not cls._migration_folder.exists():
+            raise MigrationFolderError(f"Migration folder not found: {cls._migration_folder}")
+
+        migrations = cls._get_migration_files()
+        if not migrations:
+            raise MigrationFolderError(f"No migration files found in {cls._migration_folder}")
+
+        counter = Counter([migration.migration_id for migration in migrations])
+        duplicated_migrations = [element for element, count in counter.items() if count > 1]
+        if duplicated_migrations:
+            raise MigrationFolderError(
+                f"Duplicate migration filename found: {duplicated_migrations[0]}"
+            )
+
+        return migrations
+
+    @classmethod
+    def _get_migration_files(cls) -> tuple[MigrationFile, ...]:
+        try:
+            migrations = sorted(
+                (
+                    MigrationFile.build_from_path(path)
+                    for path in cls._migration_folder.glob("*.py")
+                    if re.match(r"\d+_.*\.py", path.name)
+                ),
+                key=lambda migration_file: migration_file.order_id,
+            )
+        except ValueError as error:
+            raise MigrationFolderError(str(error)) from None
+
+        return tuple(migrations)