splent-cli 0.0.1__py3-none-any.whl

splent_cli/commands/info.py

@@ -0,0 +1,74 @@
+import click
+import base64
+import pkg_resources
+
+
+def get_metadata_value(metadata_lines, key):
+    default_value = f"{key}: Unknown"
+    line = next(
+        (line for line in metadata_lines if line.startswith(key)),
+        default_value,
+    )
+    return (
+        line.split(":", 1)[1].strip()
+        if line != default_value
+        else default_value.split(":", 1)[1].strip()
+    )
+
+
+@click.command()
+def info():
+    """Displays information about the Rosemary CLI."""
+    distribution = pkg_resources.get_distribution("splent_cli")
+
+    try:
+        metadata = distribution.get_metadata_lines("METADATA")
+        author = get_metadata_value(metadata, "Author")
+        author_email = get_metadata_value(metadata, "Author-email")
+        description = get_metadata_value(metadata, "Summary")
+    except FileNotFoundError:
+        author, author_email, description = (
+            "Unknown",
+            "Unknown",
+            "Not available",
+        )
+
+    name = distribution.project_name
+    version = distribution.version
+
+    click.echo(f"Name: {name}")
+    click.echo(f"Version: {version}")
+    click.echo(f"Author: {author}")
+    click.echo(f"Author-email: {author_email}")
+    click.echo(f"Description: {description}")
+
+
+@click.command("love:me", hidden=True)
+@click.option("--again", is_flag=True)
+def info2(again):
+    if not again:
+        click.echo(click.style("Love me --again?", fg="magenta"))
+        return
+
+    lyrics = "ICAgIA0KICAgIEtub3cgSSd2ZSBkb25lIHdyb25nLA0KICAgIExlZnQgeW91ciBoZWFydCB0b3JuDQogICAgSXMgdGhhdCB3aGF0IGRldmlscyBkbz8NCiAgICBUb29rIHlvdSBzbyBsb3csDQogICAgV2hlcmUgb25seSBmb29scyBnbw0KICAgIEkgc2hvb2sgdGhlIGFuZ2VsIGluIHlvdSENCiAgICANCiAgICBOb3cgSSdtIHJpc2luZyBmcm9tIHRoZSBncm91bmQNCiAgICBSaXNpbmcgdXAgdG8geW91IQ0KICAgIEZpbGxlZCB3aXRoIGFsbCB0aGUgc3RyZW5ndGggSSd2ZSBmb3VuZCwNCiAgICBUaGVyZSdzIG5vdGhpbmcgSSBjYW4ndCBkbyENCiAgICANCiAgICBJIG5lZWQgdG8ga25vdyBub3csIGtub3cgbm93LCBjYW4geW91IGxvdmUgbWUgYWdhaW4/DQogICAgSSBuZWVkIHRvIGtub3cgbm93LCBrbm93IG5vdywgY2FuIHlvdSBsb3ZlIG1lIGFnYWluPw0KICAgIEkgbmVlZCB0byBrbm93IG5vdywga25vdyBub3csIGNhbiB5b3UgbG92ZSBtZSBhZ2Fpbj8NCiAgICBJIG5lZWQgdG8ga25vdyBub3csIGtub3cgbm93LCBjYW4geW91IGxvdmUgbWUgYWdhaW4/DQogICAgDQogICAgSSdsbCBzcGluIHlvdSBhcm91bmQsIHdvbid0IGxldCB5b3UgZmFsbCBkb3duLA0KICAgIFdvdWxkIHlvdSBsZXQgbWUgZG93bj8gTm8hDQogICAgSSdsbCBzcGluIHlvdSBhcm91bmQsIHdvbid0IGxldCB5b3UgZmFsbCBkb3duLA0KICAgIFdvdWxkIHlvdSBsZXQgbWUgZG93bj8gTm8hDQogICAgDQogICAgTm93IEknbSByaXNpbmcgZnJvbSB0aGUgZ3JvdW5kDQogICAgUmlzaW5nIHVwIHRvIHlvdSENCiAgICBGaWxsZWQgd2l0aCBhbGwgdGhlIHN0cmVuZ3RoIEkndmUgZm91bmQsDQogICAgVGhlcmUncyBub3RoaW5nIEkgY2FuJ3QgZG8hDQogICAgDQogICAgSSBuZWVkIHRvIGtub3cgbm93LCBrbm93IG5vdywgY2FuIHlvdSBsb3ZlIG1lIGFnYWluPw0KICAgIEkgbmVlZCB0byBrbm93IG5vdywga25vdyBub3csIGNhbiB5b3UgbG92ZSBtZSBhZ2Fpbj8NCiAgICBJIG5lZWQgdG8ga25vdyBub3csIGtub3cgbm93LCBjYW4geW91IGxvdmUgbWUgYWdhaW4/DQogICAgSSBuZWVkIHRvIGtub3cgbm93LCBrbm93IG5vdywgY2FuIHlvdSBsb3ZlIG1lIGFnYWluPw0KDQogICAgQ29uZ3JhdHVsYXRpb25zLCB5b3UgZm91bmQgdGhlIGVhc3RlciBlZ2ch"  # noqa
+
+    decoded = decode_lyrics(lyrics)
+    colored_lyrics = colorize_lyrics(decoded)
+    click.echo(colored_lyrics)
+
+
+def colorize_lyrics(lyrics):
+    colored_lyrics = ""
+    colors = ["red", "green", "yellow", "blue", "magenta", "cyan", "white"]
+
+    for i, line in enumerate(lyrics.splitlines()):
+        colored_lyrics += click.style(line, fg=colors[i % len(colors)]) + "\n"
+
+    return colored_lyrics
+
+
+def decode_lyrics(encoded_lyrics):
+    decoded_lyrics = base64.b64decode(encoded_lyrics.encode("utf-8")).decode(
+        "utf-8"
+    )
+    return decoded_lyrics

splent_cli/commands/linter.py

@@ -0,0 +1,146 @@
+import click
+import subprocess
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command("linter", help="Runs Ruff linter on the project.")
+def linter():
+    """Ejecuta Ruff para analizar el código en busca de errores."""
+    directories = [
+        PathUtils.get_app_dir(),
+        PathUtils.get_splent_cli_dir(),
+        PathUtils.get_core_dir(),
+    ]
+
+    click.echo(
+        click.style("\n📌 Running Ruff Linter...\n", fg="cyan", bold=True)
+    )
+
+    for directory in directories:
+        click.echo(
+            click.style(
+                f"🔍 Checking {directory}...\n", fg="yellow", bold=True
+            )
+        )
+        result = subprocess.run(
+            ["ruff", "check", directory], capture_output=True, text=True
+        )
+
+        if result.returncode != 0:
+            click.echo(click.style(result.stdout, fg="red"))
+            click.echo(
+                click.style(
+                    f"❌ Issues found in {directory}.\n", fg="red", bold=True
+                )
+            )
+        else:
+            click.echo(
+                click.style(
+                    f"✅ No issues found in {directory}. 🎉\n",
+                    fg="green",
+                    bold=True,
+                )
+            )
+
+    click.echo(
+        click.style("✔️ Linter check completed!\n", fg="cyan", bold=True)
+    )
+
+
+@click.command(
+    "linter:fix",
+    help="Automatically formats and fixes code using Ruff and Black.",
+)
+def linter_fix():
+    """Ejecuta Ruff en modo 'fix' y luego Black para formateo."""
+    directories = [
+        PathUtils.get_app_dir(),
+        PathUtils.get_splent_cli_dir(),
+        PathUtils.get_core_dir(),
+    ]
+
+    click.echo(
+        click.style(
+            "\n📌 Running Ruff Fix & Black Formatter...\n",
+            fg="cyan",
+            bold=True,
+        )
+    )
+
+    fixes_applied = 0
+
+    for directory in directories:
+        click.echo(
+            click.style(
+                f"🔧 Fixing {directory} with Ruff...\n", fg="yellow", bold=True
+            )
+        )
+        result = subprocess.run(
+            ["ruff", "check", "--fix", directory],
+            capture_output=True,
+            text=True,
+        )
+
+        if "Fixed" in result.stdout:
+            click.echo(click.style(result.stdout, fg="blue"))
+            fixes_applied += 1
+        else:
+            click.echo(
+                click.style(
+                    f"✅ No fixes needed in {directory}. 🎉\n",
+                    fg="green",
+                    bold=True,
+                )
+            )
+
+        click.echo(
+            click.style(
+                f"🎨 Formatting {directory} with Black...\n",
+                fg="yellow",
+                bold=True,
+            )
+        )
+        black_result = subprocess.run(
+            ["black", "--line-length=79", directory],
+            capture_output=True,
+            text=True,
+        )
+
+        if black_result.returncode == 0:
+            click.echo(
+                click.style(
+                    f"✨ Code in {directory} formatted successfully!\n",
+                    fg="green",
+                    bold=True,
+                )
+            )
+        else:
+            click.echo(
+                click.style(
+                    f"❌ Failed to format {directory} with Black.\n",
+                    fg="red",
+                    bold=True,
+                )
+            )
+
+    click.echo(
+        click.style("\n✔️ Fix & Formatting Completed!", fg="cyan", bold=True)
+    )
+
+    if fixes_applied > 0:
+        click.echo(
+            click.style(
+                f"🔧 Ruff applied fixes in {fixes_applied} directories!",
+                fg="blue",
+                bold=True,
+            )
+        )
+    else:
+        click.echo(
+            click.style(
+                "🚀 No fixes were needed! Your code is already clean! 🎉",
+                fg="green",
+                bold=True,
+            )
+        )

splent_cli/commands/locust.py

@@ -0,0 +1,219 @@
+import os
+import subprocess
+import click
+import docker
+import signal
+import psutil
+
+
+@click.command(
+    "locust", help="Launches Locust for load testing based on the environment."
+)
+@click.argument("module", required=False)
+def locust(module):
+
+    # Absolute paths
+    working_dir = os.getenv("WORKING_DIR", "")
+    core_dir = os.path.join(working_dir, "core")
+    docker_dir = os.path.join(working_dir, "docker/")
+    modules_dir = os.path.join(working_dir, "app/modules")
+
+    def validate_module(module):
+        """Check if the module exists."""
+        if module:
+            module_path = os.path.join(modules_dir, module)
+            if not os.path.exists(module_path):
+                raise click.UsageError(f"module '{module}' does not exist.")
+            locustfile_path = os.path.join(
+                module_path, "tests", "locustfile.py"
+            )
+            if not os.path.exists(locustfile_path):
+                raise click.UsageError(
+                    f"Locustfile for module '{module}' does not exist at path "
+                    f"'{locustfile_path}'."
+                )
+
+    def run_docker_locust(volume_name, module):
+        """Build and run the Locust container with the specified volume."""
+
+        try:
+            # Check if the container already exists
+            client.containers.get("locust_container")
+            click.echo("Locust container is already running.")
+            return
+        except docker.errors.NotFound:
+            pass  # Container does not exist, proceed to create it
+
+        click.echo(
+            f"Starting Locust in Docker environment on port 8089 with volume: {volume_name}..."
+        )
+
+        # Build Locust's image
+        build_command = [
+            "docker",
+            "build",
+            "-f",
+            os.path.join(docker_dir, "images/Dockerfile.locust"),
+            "-t",
+            "locust-image",
+            ".",
+        ]
+        click.echo(f"Build command: {' '.join(build_command)}")
+        subprocess.run(build_command, check=True)
+
+        # Define the locustfile path
+        locustfile_path = os.path.join(
+            core_dir, "bootstraps/locustfile_bootstrap.py"
+        )
+        if module:
+            locustfile_path = f"{modules_dir}/{module}/tests/locustfile.py"
+
+        # Run the Locust container
+        up_command = [
+            "docker",
+            "run",
+            "-d",
+            "-p",
+            "8089:8089",
+            "-v",
+            f"{volume_name}:/app",
+            "--name",
+            "locust_container",
+            "--network",
+            "docker_flasky_network",
+            "locust-image",
+            "-f",
+            locustfile_path,
+        ]
+
+        click.echo(f"Docker Run command: {' '.join(up_command)}")
+        subprocess.run(up_command, check=True)
+        click.echo(
+            click.style(
+                "Locust is running at http://localhost:8089", fg="green"
+            )
+        )
+
+    def is_locust_running():
+        """Check if Locust is already running."""
+        for proc in psutil.process_iter(["pid", "name"]):
+            if proc.info["name"] == "locust":
+                return True
+        return False
+
+    def run_in_console(module):
+
+        if is_locust_running():
+            click.echo("Locust is already running.")
+            return
+
+        locustfile_path = os.path.join(
+            core_dir, "bootstraps/locustfile_bootstrap.py"
+        )
+        if module:
+            locustfile_path = os.path.join(
+                modules_dir, module, "tests", "locustfile.py"
+            )
+        locust_command = ["locust", "-f", locustfile_path]
+        click.echo(f"Locust command: {' '.join(locust_command)}")
+        subprocess.Popen(
+            locust_command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        click.echo(
+            click.style(
+                "Locust is running at http://localhost:8089", fg="green"
+            )
+        )
+
+    def run_local_locust(module):
+        """Run Locust in the local environment."""
+        click.echo("Starting Locust in local environment on port 8089...")
+        run_in_console(module)
+
+    def run_vagrant_locust(module):
+        """Run Locust in the Vagrant environment."""
+        click.echo("Starting Locust in Vagrant environment on port 8089...")
+        run_in_console(module)
+
+    # Validate module if provided
+    if module:
+        validate_module(module)
+
+    if working_dir == "/app/":
+        client = docker.from_env()
+
+        try:
+            web_container = client.containers.get("web_app_container")
+            volume_name = next(
+                (
+                    mount.get("Name") or mount.get("Source")
+                    for mount in web_container.attrs["Mounts"]
+                    if mount["Destination"] == "/app"
+                ),
+                None,
+            )
+
+            if not volume_name:
+                raise ValueError(
+                    "No volume or bind mount found mounted on /app"
+                )
+
+            run_docker_locust(volume_name, module)
+
+        except docker.errors.NotFound:
+            click.echo(click.style("Web container not found.", fg="red"))
+        except Exception as e:
+            click.echo(click.style(f"An error occurred: {str(e)}", fg="red"))
+
+    elif working_dir == "":
+        run_local_locust(module)
+
+    elif working_dir == "/vagrant/":
+        run_vagrant_locust(module)
+
+    else:
+        click.echo(
+            click.style(f"Unrecognized WORKING_DIR: {working_dir}", fg="red")
+        )
+
+
+@click.command(
+    "locust:stop", help="Stops the Locust container if it is running."
+)
+def stop():
+    working_dir = os.getenv("WORKING_DIR", "")
+
+    def stop_local_locust():
+        """Stop Locust process in the local environment."""
+        click.echo("Stopping Locust in local environment...")
+        for proc in psutil.process_iter(["pid", "name"]):
+            if proc.info["name"] == "locust":
+                click.echo(
+                    f"Stopping Locust process with PID {proc.info['pid']}..."
+                )
+                os.kill(proc.info["pid"], signal.SIGTERM)
+
+    def stop_docker_locust():
+        click.echo("Stopping Locust container if it is running...")
+        stop_command = ["docker", "stop", "locust_container"]
+        rm_command = ["docker", "rm", "locust_container"]
+
+        # Stop the Locust container if it is running
+        subprocess.run(stop_command)
+
+        # Remove the Locust container
+        subprocess.run(rm_command)
+
+    if working_dir == "/app/":
+        stop_docker_locust()
+
+    elif working_dir == "" or working_dir == "/vagrant/":
+        stop_local_locust()
+
+    else:
+        click.echo(
+            click.style(f"Unrecognized WORKING_DIR: {working_dir}", fg="red")
+        )

splent_cli/commands/module_create.py

@@ -0,0 +1,138 @@
+import stat
+import click
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+import os
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+def pascalcase(s):
+    """Converts string to PascalCase."""
+    return "".join(word.capitalize() for word in s.split("_"))
+
+
+def setup_jinja_env():
+    """Configures and returns a Jinja environment."""
+    env = Environment(
+        loader=FileSystemLoader(
+            searchpath=PathUtils.get_splent_cli_templates_dir()
+        ),
+        autoescape=select_autoescape(["html", "xml", "j2"]),
+    )
+    env.filters["pascalcase"] = pascalcase
+    return env
+
+
+def render_and_write_file(env, template_name, filename, context):
+    """Renders a template and writes it to a specified file."""
+    template = env.get_template(template_name)
+    content = template.render(context) + "\n"
+    with open(filename, "w") as f:
+        f.write(content)
+
+
+@click.command("module:create", help="Creates a new module with a given name.")
+@click.argument("name")
+def make_module(name):
+    modules_dir = PathUtils.get_modules_dir()
+    module_path = f"{modules_dir}/{name}"
+
+    if os.path.exists(module_path):
+        click.echo(
+            click.style(f"The module '{name}' already exists.", fg="red")
+        )
+        return
+
+    env = setup_jinja_env()
+
+    # Defines the directories to create.
+    directories = {"templates"}
+
+    files_and_templates = {
+        "__init__.py": "module_init.py.j2",
+        "routes.py": "module_routes.py.j2",
+        "models.py": "module_models.py.j2",
+        "repositories.py": "module_repositories.py.j2",
+        "services.py": "module_services.py.j2",
+        "forms.py": "module_forms.py.j2",
+        "seeders.py": "module_seeders.py.j2",
+        os.path.join(
+            "templates", name, "index.html"
+        ): "module_templates_index.html.j2",
+        "assets/js/scripts.js": "module_scripts.js.j2",
+        "assets/js/webpack.config.js": "module_webpack.config.js.j2",
+        "tests/test_unit.py": "module_tests_test_unit.py.j2",
+        "tests/locustfile.py": "module_tests_locustfile.py.j2",
+        "tests/test_selenium.py": "module_tests_test_selenium.py.j2",
+    }
+
+    # Create the necessary directories, explicitly excluding 'tests' from the creation of subfolders.
+    for directory in directories:
+        os.makedirs(os.path.join(module_path, directory, name), exist_ok=True)
+
+    # Create 'tests' directory directly under module_path, without additional subfolders.
+    os.makedirs(os.path.join(module_path, "tests"), exist_ok=True)
+
+    # Create 'assets' directory directly under module_path
+    os.makedirs(os.path.join(module_path, "assets", "css"), exist_ok=True)
+    os.makedirs(os.path.join(module_path, "assets", "js"), exist_ok=True)
+
+    # Create empty __init__.py file directly in the 'tests' directory.
+    open(os.path.join(module_path, "tests", "__init__.py"), "a").close()
+
+    # Render and write files, including 'test_unit.py' directly in 'tests'.
+    for filename, template_name in files_and_templates.items():
+        if template_name:  # Check if there is a defined template.
+            render_and_write_file(
+                env,
+                template_name,
+                os.path.join(module_path, filename),
+                {"module_name": name},
+            )
+        else:
+            open(
+                os.path.join(module_path, filename), "a"
+            ).close()  # Create empty file if there is no template.
+
+    click.echo(
+        click.style(f"Module '{name}' created successfully.", fg="green")
+    )
+
+    # Change the owner of the main folder of the module
+    os.chown(module_path, 1000, 1000)
+
+    # Change permissions to drwxrwxr-x (chmod 775)
+    os.chmod(
+        module_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH
+    )
+
+    # Change the owner of all created files and directories to UID 1000 and GID 1000
+    uid = 1000
+    gid = 1000
+
+    for root, dirs, files in os.walk(module_path):
+        for dir_ in dirs:
+            dir_path = os.path.join(root, dir_)
+            os.chown(dir_path, uid, gid)
+            os.chmod(
+                dir_path,
+                stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH,
+            )
+
+        for file_ in files:
+            file_path = os.path.join(root, file_)
+            os.chown(file_path, uid, gid)
+            os.chmod(
+                file_path,
+                stat.S_IRUSR
+                | stat.S_IWUSR
+                | stat.S_IRGRP
+                | stat.S_IWGRP
+                | stat.S_IROTH,
+            )
+
+    click.echo(
+        click.style(
+            f"Module '{name}' permissions changed successfully.", fg="green"
+        )
+    )

splent_cli/commands/module_list.py

@@ -0,0 +1,28 @@
+import click
+from flask.cli import with_appcontext
+from splent_app import splent_app
+from splent_framework.core.managers.module_manager import ModuleManager
+
+
+@click.command(
+    "module:list", help="Lists all modules and those ignored by .moduleignore."
+)
+@with_appcontext
+def module_list():
+    manager = ModuleManager(splent_app)
+
+    loaded_modules, ignored_modules = manager.get_modules()
+
+    click.echo(
+        click.style(f"Loaded Modules ({len(loaded_modules)}):", fg="green")
+    )
+    for module in loaded_modules:
+        click.echo(f"- {module}")
+
+    click.echo(
+        click.style(
+            f"\nIgnored Modules ({len(ignored_modules)}):", fg="bright_yellow"
+        )
+    )
+    for module in ignored_modules:
+        click.echo(click.style(f"- {module}", fg="bright_yellow"))

splent_cli/commands/route_list.py

@@ -0,0 +1,68 @@
+import os
+import click
+from flask import current_app
+from flask.cli import with_appcontext
+from collections import defaultdict
+
+
+@click.command("route:list", help="Lists all routes of the Flask application.")
+@click.argument("module_name", required=False)
+@click.option(
+    "--group",
+    is_flag=True,
+    help="Group routes by module when no specific module is provided.",
+)
+@with_appcontext
+def route_list(module_name, group):
+    base_path = os.path.join(os.getenv("WORKING_DIR", ""), "app/modules")
+
+    # Checks if a module was specified and if it exists
+    if module_name:
+        module_path = os.path.join(base_path, module_name)
+        if not os.path.exists(module_path):
+            click.echo(
+                click.style(
+                    f"Module '{module_name}' does not exist.", fg="red"
+                )
+            )
+            return
+        click.echo(f"Listing routes for the '{module_name}' module...")
+        # Path filtering for a specific module
+        filtered_rules = [
+            rule
+            for rule in current_app.url_map.iter_rules()
+            if rule.endpoint.startswith(f"{module_name}.")
+        ]
+        print_route_table(filtered_rules)
+    else:
+        if group:  # Group routes by module
+            click.echo("Listing routes for all modules, grouped by module...")
+            rules = sorted(
+                current_app.url_map.iter_rules(),
+                key=lambda rule: rule.endpoint,
+            )
+            grouped_rules = defaultdict(list)
+            for rule in rules:
+                module = rule.endpoint.split(".")[0]
+                grouped_rules[module].append(rule)
+
+            for module, rules in sorted(grouped_rules.items()):
+                click.echo(click.style(f"\nModule: {module}", fg="yellow"))
+                print_route_table(rules)
+        else:  # Lists all routes without grouping
+            click.echo("Listing routes for all modules...")
+            rules = sorted(
+                current_app.url_map.iter_rules(),
+                key=lambda rule: rule.endpoint,
+            )
+            print_route_table(rules)
+
+
+def print_route_table(rules):
+    click.echo(f"{'Endpoint':<50} {'Methods':<30} {'Route':<100}")
+    click.echo("-" * 180)
+    for rule in rules:
+        methods = ", ".join(
+            sorted(rule.methods.difference({"HEAD", "OPTIONS"}))
+        )
+        click.echo(f"{rule.endpoint:<50} {methods:<30} {rule.rule:<100}")