splent-cli 0.0.1__py3-none-any.whl

splent_cli/__init__.py

@@ -0,0 +1,6 @@
+import os
+import sys
+
+# Add the project's root directory to the PYTHONPATH
+# This allows Python to locate modules in the parent directory, enabling relative imports.
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))

splent_cli/__main__.py

@@ -0,0 +1,11 @@
+from splent_cli.cli import check_working_dir, cli, load_commands
+
+
+def main():
+    check_working_dir()
+    load_commands(cli)
+    cli()
+
+
+if __name__ == "__main__":
+    main()

splent_cli/cli.py

@@ -0,0 +1,59 @@
+import os
+import sys
+import importlib
+import click
+from dotenv import load_dotenv
+from flask.cli import FlaskGroup  # 📌 Añadir FlaskGroup
+from splent_app import create_app  # 📌 Importar la app de Flask
+
+from splent_cli.utils.path_utils import PathUtils
+
+load_dotenv()
+
+
+def check_working_dir():
+    working_dir = os.getenv("WORKING_DIR", "").strip()
+
+    if not working_dir:
+        return
+
+    if working_dir in ["/app", "/vagrant", "/app/", "/vagrant/"] and not os.path.exists(working_dir):
+        print(f"⚠️  WARNING: WORKING_DIR is set to '{working_dir}', but the directory does not exist.")
+        sys.exit(1)
+
+
+class SPLENTCLI(FlaskGroup):  # 📌 Usamos FlaskGroup para conectar con Flask
+    def __init__(self, **kwargs):
+        super().__init__(create_app=create_app, **kwargs)
+
+    def get_command(self, ctx, cmd_name):
+        rv = super().get_command(ctx, cmd_name)
+        if rv is None:
+            click.echo(f"No such command '{cmd_name}'.")
+            click.echo("Try 'splent_cli --help' for a list of available commands.")
+        return rv
+
+
+def load_commands(cli_group, commands_dir="splent_cli/commands"):
+    """
+    Dynamically import all commands in the specified directory and add them to the CLI group.
+    """
+    commands_path = PathUtils.get_commands_path()
+
+    for file in os.listdir(commands_path):
+        if file.endswith(".py") and not file.startswith("__"):
+            module_name = f"splent_cli.commands.{file[:-3]}"
+            module = importlib.import_module(module_name)
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if isinstance(attr, click.Command):
+                    cli_group.add_command(attr)
+
+
+@click.group(cls=SPLENTCLI)
+def cli():
+    """A CLI tool to help with project development."""
+
+
+if __name__ == "__main__":
+    cli()

splent_cli/commands/clear_cache.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+
+import click
+import shutil
+import os
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command(
+    "clear:cache",
+    help="Clears pytest cache in app/modules and the build directory at the root.",
+)
+def clear_cache():
+
+    if click.confirm(
+        "Are you sure you want to clear the pytest cache and the build directory?"
+    ):
+
+        project_root = Path(os.getenv("WORKING_DIR", ""))
+
+        pytest_cache_dir = os.path.join(
+            PathUtils.get_modules_dir(), ".pytest_cache"
+        )
+
+        build_dir = os.path.join(os.getenv("WORKING_DIR", ""), "build")
+
+        if os.path.exists(pytest_cache_dir):
+            try:
+                shutil.rmtree(pytest_cache_dir)
+                click.echo(click.style("Pytest cache cleared.", fg="green"))
+            except Exception as e:
+                click.echo(
+                    click.style(f"Failed to clear pytest cache: {e}", fg="red")
+                )
+        else:
+            click.echo(
+                click.style(
+                    "No pytest cache found. Nothing to clear.", fg="yellow"
+                )
+            )
+
+        if os.path.exists(build_dir):
+            try:
+                shutil.rmtree(build_dir)
+                click.echo(click.style("Build directory cleared.", fg="green"))
+            except Exception as e:
+                click.echo(
+                    click.style(
+                        f"Failed to clear build directory: {e}", fg="red"
+                    )
+                )
+        else:
+            click.echo(
+                click.style(
+                    "No cache or build directory found. Nothing to clear.",
+                    fg="yellow",
+                )
+            )
+
+        pycache_dirs = project_root.rglob("__pycache__")
+        for dir in pycache_dirs:
+            try:
+                shutil.rmtree(dir)
+            except Exception as e:
+                click.echo(
+                    click.style(
+                        f"Failed to clear __pycache__ directory {dir}: {e}",
+                        fg="red",
+                    )
+                )
+        click.echo(
+            click.style("All __pycache__ directories cleared.", fg="green")
+        )
+
+        pyc_files = project_root.rglob("*.pyc")
+        for file in pyc_files:
+            try:
+                file.unlink()
+            except Exception as e:
+                click.echo(
+                    click.style(
+                        f"Failed to clear .pyc file {file}: {e}", fg="red"
+                    )
+                )
+
+        click.echo(click.style("All cache cleared.", fg="green"))
+
+    else:
+        click.echo(click.style("Clear operation cancelled.", fg="yellow"))

splent_cli/commands/clear_log.py

@@ -0,0 +1,31 @@
+import click
+import os
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command("clear:log", help="Clears the 'app.log' file.")
+def clear_log():
+    log_file_path = PathUtils.get_app_log_dir()
+
+    # Check if the log file exists
+    if os.path.exists(log_file_path):
+        try:
+            # Deletes the log file
+            os.remove(log_file_path)
+            click.echo(
+                click.style(
+                    "The 'app.log' file has been successfully cleared.",
+                    fg="green",
+                )
+            )
+        except Exception as e:
+            click.echo(
+                click.style(
+                    f"Error clearing the 'app.log' file: {e}", fg="red"
+                )
+            )
+    else:
+        click.echo(
+            click.style("The 'app.log' file does not exist.", fg="yellow")
+        )

splent_cli/commands/clear_uploads.py

@@ -0,0 +1,44 @@
+import click
+import shutil
+import os
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command(
+    "clear:uploads",
+    help="Clears the contents of the 'uploads' directory without removing the folder.",
+)
+def clear_uploads():
+    uploads_dir = PathUtils.get_uploads_dir()
+
+    # Verify if the 'uploads' folder exists
+    if os.path.exists(uploads_dir) and os.path.isdir(uploads_dir):
+        try:
+            # Iterate over the contents of the directory
+            for filename in os.listdir(uploads_dir):
+                file_path = os.path.join(uploads_dir, filename)
+
+                # If it's a file, remove it
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.remove(file_path)
+                # If it's a directory, remove it and its contents
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+
+            click.echo(
+                click.style(
+                    "The contents of the 'uploads' directory have been successfully cleared.",
+                    fg="green",
+                )
+            )
+        except Exception as e:
+            click.echo(
+                click.style(
+                    f"Error clearing the 'uploads' directory: {e}", fg="red"
+                )
+            )
+    else:
+        click.echo(
+            click.style("The 'uploads' directory does not exist.", fg="yellow")
+        )

splent_cli/commands/compose_env.py

@@ -0,0 +1,50 @@
+import os
+import click
+from dotenv import dotenv_values
+from flask.cli import with_appcontext
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command(
+    "compose:env",
+    help="Combines .env files from blueprints with the root .env, checking for conflicts.",
+)
+@with_appcontext
+def compose_env():
+
+    modules_dir = PathUtils.get_modules_dir()
+    root_env_path = PathUtils.get_env_dir()
+
+    # Loads the current root .env variables into a dictionary
+    root_env_vars = dotenv_values(root_env_path)
+
+    # Finds and processes all blueprints .env files
+    module_env_paths = [
+        os.path.join(root, ".env")
+        for root, dirs, files in os.walk(modules_dir)
+        if ".env" in files
+    ]
+    for env_path in module_env_paths:
+        blueprint_env_vars = dotenv_values(env_path)
+        # Add or update the blueprint variables in the root .env dictionary
+        for key, value in blueprint_env_vars.items():
+            if key in root_env_vars and root_env_vars[key] != value:
+                conflict_msg = (
+                    f"Conflict found for variable '{key}' in {env_path}. "
+                    "Keeping the original value."
+                )
+                click.echo(click.style(conflict_msg, fg="yellow"))
+                continue
+            root_env_vars[key] = value
+
+    # Write back to the root .env file
+    with open(root_env_path, "w") as root_env_file:
+        for key, value in root_env_vars.items():
+            root_env_file.write(f"{key}={value}\n")
+
+    click.echo(
+        click.style(
+            "Successfully merged .env files without conflicts.", fg="green"
+        )
+    )

splent_cli/commands/coverage.py

@@ -0,0 +1,46 @@
+import click
+import subprocess
+import os
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command(
+    "coverage",
+    help="Runs pytest coverage on the blueprints directory or a specific module.",
+)
+@click.argument("module_name", required=False)
+@click.option(
+    "--html", is_flag=True, help="Generates an HTML coverage report."
+)
+def coverage(module_name, html):
+    modules_dir = PathUtils.get_modules_dir()
+    test_path = modules_dir
+
+    if module_name:
+        test_path = os.path.join(modules_dir, module_name)
+        if not os.path.exists(test_path):
+            click.echo(
+                click.style(
+                    f"Module '{module_name}' does not exist.", fg="red"
+                )
+            )
+            return
+        click.echo(f"Running coverage for the '{module_name}' module...")
+    else:
+        click.echo("Running coverage for all modules...")
+
+    coverage_cmd = [
+        "pytest",
+        "--ignore-glob=*selenium*",
+        "--cov=" + test_path,
+        test_path,
+    ]
+
+    if html:
+        coverage_cmd.extend(["--cov-report", "html"])
+
+    try:
+        subprocess.run(coverage_cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"Error running coverage: {e}", fg="red"))

splent_cli/commands/db_console.py

@@ -0,0 +1,27 @@
+import click
+import subprocess
+from dotenv import load_dotenv
+import os
+
+
+@click.command(
+    "db:console", help="Opens a MariaDB console with credentials from .env."
+)
+def db_console():
+    load_dotenv()
+
+    mariadb_hostname = os.getenv("MARIADB_HOSTNAME")
+    mariadb_user = os.getenv("MARIADB_USER")
+    mariadb_password = os.getenv("MARIADB_PASSWORD")
+    mariadb_database = os.getenv("MARIADB_DATABASE")
+
+    # Build the command to connect to MariaDB
+    mariadb_connect_cmd = f"mysql -h{mariadb_hostname} -u{mariadb_user} -p{mariadb_password} {mariadb_database}"
+
+    # Execute the command
+    try:
+        subprocess.run(mariadb_connect_cmd, shell=True, check=True)
+    except subprocess.CalledProcessError as e:
+        click.echo(
+            click.style(f"Error opening MariaDB console: {e}", fg="red")
+        )

splent_cli/commands/db_dump.py

@@ -0,0 +1,45 @@
+import click
+import subprocess
+from dotenv import load_dotenv
+import os
+from datetime import datetime
+
+
+@click.command(
+    "db:dump",
+    help="Creates a dump of the MariaDB database with credentials from .env.",
+)
+@click.argument("filename", required=False)
+def db_dump(filename):
+    load_dotenv()
+
+    mariadb_hostname = os.getenv("MARIADB_HOSTNAME")
+    mariadb_user = os.getenv("MARIADB_USER")
+    mariadb_password = os.getenv("MARIADB_PASSWORD")
+    mariadb_database = os.getenv("MARIADB_DATABASE")
+
+    # Generate default filename if not provided
+    if not filename:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"dump_{timestamp}.sql"
+    else:
+        # Ensure filename has .sql extension
+        if not filename.endswith(".sql"):
+            filename += ".sql"
+
+    # Build the mysqldump command
+    dump_cmd = f"mysqldump -h{mariadb_hostname} -u{mariadb_user} -p{mariadb_password} \
+        {mariadb_database} > {filename}"
+
+    # Execute the command
+    try:
+        subprocess.run(
+            dump_cmd, shell=True, check=True, executable="/bin/bash"
+        )
+        click.echo(
+            click.style(
+                f"Database dump created successfully: {filename}", fg="green"
+            )
+        )
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"Error creating database dump: {e}", fg="red"))

splent_cli/commands/db_migrate.py

@@ -0,0 +1,37 @@
+import subprocess
+import click
+from flask.cli import with_appcontext
+
+
+@click.command("db:migrate", help="Generates and applies database migrations.")
+@with_appcontext
+def db_migrate():
+    # Generates migrations
+    click.echo("Generating database migrations...")
+    result_migrate = subprocess.run(["flask", "db", "migrate"])
+    if result_migrate.returncode == 0:
+        click.echo(
+            click.style("Migrations generated successfully.", fg="green")
+        )
+    else:
+        click.echo(
+            click.style(
+                "Note: No new migrations needed or an error occurred "
+                "while generating migrations.",
+                fg="yellow",
+            )
+        )
+
+    # Applies to migrations
+    click.echo("Applying database migrations...")
+    result_upgrade = subprocess.run(["flask", "db", "upgrade"])
+    if result_upgrade.returncode == 0:
+        click.echo(click.style("Migrations applied successfully.", fg="green"))
+    else:
+        click.echo(
+            click.style(
+                "Error applying migrations. This may be due to the database "
+                "being already up-to-date.",
+                fg="yellow",
+            )
+        )

splent_cli/commands/db_reset.py

@@ -0,0 +1,90 @@
+import click
+import shutil
+import os
+import subprocess
+from flask.cli import with_appcontext
+from splent_app import create_app, db
+from sqlalchemy import MetaData
+
+from splent_cli.commands.clear_uploads import clear_uploads
+
+
+@click.command(
+    "db:reset",
+    help="Resets the database, optionally clears migrations and recreates them.",
+)
+@click.option(
+    "--clear-migrations",
+    is_flag=True,
+    help="Remove all tables including 'alembic_version', clear migrations folder, and recreate migrations.",
+)
+@click.option(
+    "-y",
+    "--yes",
+    is_flag=True,
+    help="Confirm the operation without prompting.",
+)
+@with_appcontext
+def db_reset(clear_migrations, yes):
+    app = create_app()
+    with app.app_context():
+        if not yes and not click.confirm(
+            "WARNING: This will delete all data and clear uploads. Are you sure?",
+            abort=True,
+        ):
+            return
+
+        # Deletes data from all tables
+        try:
+            meta = MetaData()
+            meta.reflect(bind=db.engine)
+            with db.engine.connect() as conn:
+                trans = conn.begin()  # Begin transaction
+                for table in reversed(meta.sorted_tables):
+                    if not clear_migrations or table.name != "alembic_version":
+                        conn.execute(table.delete())
+                trans.commit()  # End transaction
+            click.echo(click.style("All table data cleared.", fg="yellow"))
+            subprocess.run(["flask", "db", "stamp", "head"], check=True)
+        except Exception as e:
+            click.echo(
+                click.style(f"Error clearing table data: {e}", fg="red")
+            )
+            if trans:
+                trans.rollback()
+            return
+
+        # Delete the uploads folder
+        ctx = click.get_current_context()
+        ctx.invoke(clear_uploads)
+
+        if clear_migrations:
+            # Delete the migration folder if it exists.
+            migrations_dir = os.path.join(
+                os.getenv("WORKING_DIR", ""), "migrations"
+            )
+            if os.path.isdir(migrations_dir):
+                shutil.rmtree(migrations_dir)
+                click.echo(
+                    click.style("Migrations directory cleared.", fg="yellow")
+                )
+
+            # Run flask db init, migrate and upgrade
+            try:
+                subprocess.run(["flask", "db", "init"], check=True)
+                subprocess.run(["flask", "db", "migrate"], check=True)
+                subprocess.run(["flask", "db", "upgrade"], check=True)
+                click.echo(
+                    click.style(
+                        "Database recreated from new migrations.", fg="green"
+                    )
+                )
+            except subprocess.CalledProcessError as e:
+                click.echo(
+                    click.style(
+                        f"Error during migrations reset: {e}", fg="red"
+                    )
+                )
+                return
+
+        click.echo(click.style("Database reset successfully.", fg="green"))

splent_cli/commands/db_seed.py

@@ -0,0 +1,123 @@
+import inspect
+import os
+import importlib
+import click
+from flask.cli import with_appcontext
+
+
+from splent_framework.core.seeders import BaseSeeder
+from splent_cli.commands.db_reset import db_reset
+
+
+def get_module_seeders(module_path, specific_module=None):
+    seeders = []
+    for root, dirs, files in os.walk(module_path):
+        if "seeders.py" in files:
+            relative_path = os.path.relpath(root, module_path)
+            module_name = relative_path.replace(os.path.sep, ".")
+            full_module_name = f"app.modules.{module_name}.seeders"
+
+            # If a module was specified and does not match the current one, continue with the next one
+            if (
+                specific_module
+                and specific_module != module_name.split(".")[0]
+            ):
+                continue
+
+            seeder_module = importlib.import_module(full_module_name)
+            importlib.reload(seeder_module)  # Reload the module
+
+            for attr in dir(seeder_module):
+                potential_seeder_class = getattr(seeder_module, attr)
+                if (
+                    inspect.isclass(potential_seeder_class)
+                    and issubclass(potential_seeder_class, BaseSeeder)
+                    and potential_seeder_class is not BaseSeeder
+                ):
+                    seeders.append(potential_seeder_class())
+
+    # Sort seeders by priority
+    seeders.sort(key=lambda seeder: seeder.priority)
+
+    return seeders
+
+
+@click.command(
+    "db:seed",
+    help="Populates the database with the seeders defined in each module.",
+)
+@click.option(
+    "--reset", is_flag=True, help="Reset the database before seeding."
+)
+@click.option(
+    "-y",
+    "--yes",
+    is_flag=True,
+    help="Confirm the operation without prompting.",
+)
+@click.argument("module", required=False)
+@with_appcontext
+def db_seed(reset, yes, module):
+
+    if reset:
+        if yes or click.confirm(
+            click.style(
+                "This will reset the database, do you want " "to continue?",
+                fg="red",
+            ),
+            abort=True,
+        ):
+            click.echo(click.style("Resetting the database...", fg="yellow"))
+            ctx = click.get_current_context()
+            ctx.invoke(db_reset, clear_migrations=False, yes=True)
+        else:
+            click.echo(click.style("Database reset cancelled.", fg="yellow"))
+            return
+
+    blueprints_module_path = os.path.join(
+        os.getenv("WORKING_DIR", ""), "app/modules"
+    )
+    seeders = get_module_seeders(
+        blueprints_module_path, specific_module=module
+    )
+    success = True  # Flag to control the successful flow of the operation
+
+    if module:
+        click.echo(
+            click.style(
+                f"Seeding data for the '{module}' module...", fg="green"
+            )
+        )
+    else:
+        click.echo(click.style("Seeding data for all modules...", fg="green"))
+
+    for seeder in seeders:
+        try:
+            seeder.run()
+            click.echo(
+                click.style(
+                    f"{seeder.__class__.__name__} performed.", fg="blue"
+                )
+            )
+        except Exception as e:
+            click.echo(
+                click.style(
+                    f"Error running seeder {seeder.__class__.__name__}: {e}",
+                    fg="red",
+                )
+            )
+            click.echo(
+                click.style(
+                    f"Rolled back the transaction of {seeder.__class__.__name__} to keep the session "
+                    f"clean.",
+                    fg="yellow",
+                )
+            )
+
+            success = False
+            break
+
+    if success:
+        click.echo(
+            click.style("Database populated with test data.", fg="green")
+        )

splent_cli/commands/env.py

@@ -0,0 +1,18 @@
+# splent_cli/commands/env.py
+
+import click
+from dotenv import dotenv_values
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command()
+def env():
+    """Displays the current .env file values."""
+    # Load the .env file
+    env_dir = PathUtils.get_env_dir()
+    env_values = dotenv_values(env_dir)
+
+    # Display keys and values
+    for key, value in env_values.items():
+        click.echo(f"{key}={value}")