splent-cli 0.0.1__tar.gz → 0.0.2__tar.gz

splent_cli-0.0.2/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: splent_cli
+Version: 0.0.2
+Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
+Author-email: DiversoLab <diversolab@us.es>
+Project-URL: Homepage, https://github.com/diverso-lab/splent_cli
+Project-URL: Issues, https://github.com/diverso-lab/splent_cli/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: python-dotenv
+Requires-Dist: flask
+Requires-Dist: setuptools
+Requires-Dist: pytest
+Requires-Dist: pytest-cov
+Requires-Dist: ruff
+Requires-Dist: build
+Requires-Dist: twine
+Dynamic: license-file
+
+# splent_cli

{splent_cli-0.0.1 → splent_cli-0.0.2}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "0.0.1"
+version = "0.0.2"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.12"
-authors = [{ name = "David Romero", email = "drorganvidez@us.es" }]
-license = { file = "LICENSE" }
+authors = [{ name = "DiversoLab", email = "diversolab@us.es" }]
+license-files = ["LICENSE"]
 dependencies = [
     "click",
     "python-dotenv",
@@ -17,18 +17,22 @@ dependencies = [
     "setuptools",
     "pytest",
     "pytest-cov",
-    "ruff"
+    "ruff",
+    "build",
+    "twine"
 ]
 
-[tool.black]
-line-length = 79
-
 [project.scripts]
 splent_cli = "splent_cli.__main__:main"
 
+[tool.setuptools]
+package-dir = { "" = "src" }
+
 [tool.setuptools.packages.find]
-where = ["."]
-include = ["splent_cli*"] 
+where = ["src"]
+
+[tool.black]
+line-length = 79
 
 [project.urls]
 Homepage = "https://github.com/diverso-lab/splent_cli"

{splent_cli-0.0.1 → splent_cli-0.0.2/src}/splent_cli/__main__.py

@@ -1,11 +1,15 @@
 from splent_cli.cli import check_working_dir, cli, load_commands
+from splent_cli.utils.feature_installer import ensure_editable_features_installed
 
 
 def main():
     check_working_dir()
+    ensure_editable_features_installed()
     load_commands(cli)
     cli()
 
 
 if __name__ == "__main__":
     main()
+
+__all__ = ["main"]

{splent_cli-0.0.1 → splent_cli-0.0.2/src}/splent_cli/cli.py

@@ -3,8 +3,8 @@ 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 flask.cli import FlaskGroup
+from splent_cli.utils.dynamic_imports import get_app
 
 from splent_cli.utils.path_utils import PathUtils
 
@@ -14,17 +14,14 @@ 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.")
+    if working_dir != "/workspace":
+        print(f"❌ ERROR: WORKING_DIR must be set to '/workspace', but got '{working_dir}'.")
         sys.exit(1)
 
 
-class SPLENTCLI(FlaskGroup):  # 📌 Usamos FlaskGroup para conectar con Flask
+class SPLENTCLI(FlaskGroup):
     def __init__(self, **kwargs):
-        super().__init__(create_app=create_app, **kwargs)
+        super().__init__(create_app=get_app, **kwargs)
 
     def get_command(self, ctx, cmd_name):
         rv = super().get_command(ctx, cmd_name)
@@ -34,7 +31,7 @@ class SPLENTCLI(FlaskGroup):  # 📌 Usamos FlaskGroup para conectar con Flask
         return rv
 
 
-def load_commands(cli_group, commands_dir="splent_cli/commands"):
+def load_commands(cli_group):
     """
     Dynamically import all commands in the specified directory and add them to the CLI group.
     """

{splent_cli-0.0.1 → splent_cli-0.0.2/src}/splent_cli/commands/db_reset.py

@@ -3,10 +3,13 @@ import shutil
 import os
 import subprocess
 from flask.cli import with_appcontext
-from splent_app import create_app, db
+from splent_cli.utils.dynamic_imports import get_create_app, get_db
 from sqlalchemy import MetaData
 
 from splent_cli.commands.clear_uploads import clear_uploads
+from splent_cli.utils.path_utils import PathUtils
+
+db = get_db()
 
 
 @click.command(
@@ -26,7 +29,7 @@ from splent_cli.commands.clear_uploads import clear_uploads
 )
 @with_appcontext
 def db_reset(clear_migrations, yes):
-    app = create_app()
+    app = get_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?",
@@ -60,9 +63,7 @@ def db_reset(clear_migrations, yes):
 
         if clear_migrations:
             # Delete the migration folder if it exists.
-            migrations_dir = os.path.join(
-                os.getenv("WORKING_DIR", ""), "migrations"
-            )
+            migrations_dir = PathUtils.get_migrations_dir()
             if os.path.isdir(migrations_dir):
                 shutil.rmtree(migrations_dir)
                 click.echo(

splent_cli-0.0.2/src/splent_cli/commands/db_seed.py

@@ -0,0 +1,103 @@
+import inspect
+import os
+import importlib
+import click
+from flask.cli import with_appcontext
+
+from splent_cli.commands.db_reset import db_reset
+from splent_cli.utils.path_utils import PathUtils
+from splent_framework.core.seeders.BaseSeeder import BaseSeeder
+
+
+def get_installed_seeders(features_file_path, specific_module=None):
+    seeders = []
+    
+    if not os.path.isfile(features_file_path):
+        click.echo(f"⚠️  Features file not found: {features_file_path}")
+        return seeders
+
+    with open(features_file_path) as f:
+        for line in f:
+            feature = line.strip()
+            if not feature:
+                continue
+
+            if specific_module and specific_module != feature.split("_")[-1]:
+                continue
+
+            try:
+                seeder_module = importlib.import_module(f"{feature}.seeders")
+                importlib.reload(seeder_module)
+
+                for attr in dir(seeder_module):
+                    obj = getattr(seeder_module, attr)
+                    if (
+                        inspect.isclass(obj)
+                        and issubclass(obj, BaseSeeder)
+                        and obj is not BaseSeeder
+                    ):
+                        seeders.append(obj())
+            except Exception as e:
+                click.echo(
+                    f"❌ Error loading seeders from {feature}: {e}",
+                    err=True,
+                )
+
+    seeders.sort(key=lambda s: s.priority)
+    return seeders
+
+
+@click.command(
+    "db:seed",
+    help="Populates the database with the seeders defined in each feature.",
+)
+@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
+
+    features_file_path = PathUtils.get_features_file()
+    seeders = get_installed_seeders(features_file_path, specific_module=module)
+    success = True
+
+    if module:
+        click.echo(click.style(f"Seeding data for the '{module}' feature...", fg="green"))
+    else:
+        click.echo(click.style("Seeding data for all features...", 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.__class__.__name__}: {e}", fg="red")
+            )
+            click.echo(
+                click.style("Rolling back session for safety.", fg="yellow")
+            )
+            success = False
+            break
+
+    if success:
+        click.echo(click.style("Database populated with test data.", fg="green"))

splent_cli-0.0.2/src/splent_cli/commands/feature_create.py

@@ -0,0 +1,104 @@
+import os
+import stat
+import click
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+def pascalcase(s):
+    return "".join(word.capitalize() for word in s.split("_"))
+
+
+def setup_jinja_env():
+    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):
+    content = env.get_template(template_name).render(context) + "\n"
+    os.makedirs(os.path.dirname(filename), exist_ok=True)
+    with open(filename, "w") as f:
+        f.write(content)
+
+
+@click.command("feature:create", help="Creates a new feature with a given name.")
+@click.argument("name")
+def make_feature(name):
+    feature_name = f"splent_feature_{name}"
+    base_path = os.path.join(PathUtils.get_working_dir(), feature_name)
+    src_path = os.path.join(base_path, "src", feature_name)
+
+    if os.path.exists(base_path):
+        click.echo(click.style(f"The feature '{feature_name}' already exists.", fg="red"))
+        return
+
+    env = setup_jinja_env()
+    context = {"module_name": name}
+
+    # Archivos que van dentro de src/splent_feature_<name>
+    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",
+        os.path.join("assets", "js", "scripts.js"): "module_scripts.js.j2",
+        os.path.join("assets", "js", "webpack.config.js"): "module_webpack.config.js.j2",
+        os.path.join("tests", "__init__.py"): None,
+        os.path.join("tests", "test_unit.py"): "module_tests_test_unit.py.j2",
+        os.path.join("tests", "locustfile.py"): "module_tests_locustfile.py.j2",
+        os.path.join("tests", "test_selenium.py"): "module_tests_test_selenium.py.j2",
+    }
+
+    # Crear todos los archivos de código en src_path
+    for filename, template in files_and_templates.items():
+        full_path = os.path.join(src_path, filename)
+        if template:
+            render_and_write_file(env, template, full_path, context)
+        else:
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            open(full_path, "a").close()
+
+    # Crear src/__init__.py vacío
+    src_root = os.path.join(base_path, "src")
+    os.makedirs(src_root, exist_ok=True)
+    open(os.path.join(src_root, "__init__.py"), "a").close()
+
+    # Crear el pyproject.toml en la raíz del módulo
+    render_and_write_file(
+        env,
+        "module_pyproject.toml.j2",
+        os.path.join(base_path, "pyproject.toml"),
+        context,
+    )
+
+    # Cambiar permisos y propietario
+    uid = 1000
+    gid = 1000
+
+    os.chown(base_path, uid, gid)
+    os.chmod(base_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH)
+
+    for root, dirs, files in os.walk(base_path):
+        for d in dirs:
+            dir_path = os.path.join(root, d)
+            os.chown(dir_path, uid, gid)
+            os.chmod(dir_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH)
+        for f in files:
+            file_path = os.path.join(root, f)
+            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"Feature '{feature_name}' created successfully in {base_path}", fg="green"))

splent_cli-0.0.2/src/splent_cli/commands/feature_list.py

@@ -0,0 +1,29 @@
+import click
+from flask.cli import with_appcontext
+from splent_cli.utils.dynamic_imports import get_app
+from splent_framework.core.managers.feature_manager import FeatureManager
+
+
+@click.command(
+    "feature:list", help="Lists all feautures and those ignored by .featureignore."
+)
+@with_appcontext
+def module_list():
+    app = get_app
+    manager = FeatureManager(app)
+
+    loaded_modules, ignored_modules = manager.get_modules()
+
+    click.echo(
+        click.style(f"Loaded features ({len(loaded_modules)}):", fg="green")
+    )
+    for module in loaded_modules:
+        click.echo(f"- {module}")
+
+    click.echo(
+        click.style(
+            f"\nIgnored features ({len(ignored_modules)}):", fg="bright_yellow"
+        )
+    )
+    for module in ignored_modules:
+        click.echo(click.style(f"- {module}", fg="bright_yellow"))

{splent_cli-0.0.1 → splent_cli-0.0.2/src}/splent_cli/commands/locust.py

@@ -76,7 +76,7 @@ def locust(module):
             "-p",
             "8089:8089",
             "-v",
-            f"{volume_name}:/app",
+            f"{volume_name}:/workspace",
             "--name",
             "locust_container",
             "--network",
@@ -142,7 +142,7 @@ def locust(module):
     if module:
         validate_module(module)
 
-    if working_dir == "/app/":
+    if working_dir == "/workspace/":
         client = docker.from_env()
 
         try:
@@ -207,7 +207,7 @@ def stop():
         # Remove the Locust container
         subprocess.run(rm_command)
 
-    if working_dir == "/app/":
+    if working_dir == "/workspace/":
         stop_docker_locust()
 
     elif working_dir == "" or working_dir == "/vagrant/":

splent_cli-0.0.2/src/splent_cli/commands/product_create.py

@@ -0,0 +1,99 @@
+import os
+import shutil
+import stat
+import click
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from splent_cli.utils.path_utils import PathUtils
+
+def pascalcase(s):
+    return "".join(word.capitalize() for word in s.split("_"))
+
+
+def setup_jinja_env():
+    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):
+    content = env.get_template(template_name).render(context) + "\n"
+    os.makedirs(os.path.dirname(filename), exist_ok=True)
+    with open(filename, "w") as f:
+        f.write(content)
+
+@click.command("product:create", help="Creates a new product with a given name.")
+@click.argument("name")
+@click.option("--features-file", type=click.Path(exists=True), help="Path to features.txt")
+def make_product(name, features_file):
+    env = setup_jinja_env()
+    context = {
+        "product_name": name,
+        "pascal_name": pascalcase(name)
+    }
+
+    base_path = os.path.join(PathUtils.get_working_dir(), name)
+    src_path = os.path.join(base_path, "src", name)
+
+    if os.path.exists(base_path):
+        click.echo(click.style(f"The product '{name}' already exists.", fg="red"))
+        return
+
+    # Crear carpetas base
+    for subdir in ["entrypoints", "scripts", f"src/{name}"]:
+        os.makedirs(os.path.join(base_path, subdir), exist_ok=True)
+    open(os.path.join(base_path, "src", "__init__.py"), "a").close()
+
+    # Archivos desde plantillas
+    files_and_templates = {
+        "entrypoints/dev_entrypoint.sh": "product/product_dev_entrypoint.sh.j2",
+        "scripts/00_install_features.sh": "product/product_00_install_features.sh.j2",
+        "scripts/01_compile_assets.sh": "product/product_01_compile_assets.sh.j2",
+        "scripts/02_0_db_wait_connection.sh": "product/product_02_0_db_wait_connection.sh.j2",
+        "scripts/02_1_db_create_db_test.sh": "product/product_02_1_db_create_db_test.sh.j2",
+        "scripts/03_initialize_migrations.sh": "product/product_03_initialize_migrations.sh.j2",
+        "scripts/04_handle_migrations.sh": "product/product_04_handle_migrations.sh.j2",
+        "scripts/05_0_start_app_dev.sh": "product/product_05_0_start_app_dev.sh.j2",
+        "README.md": "product/product_README.md.j2",
+        "pyproject.toml": "product/product_pyproject.toml.j2",
+        "features.txt": "product/product_features.txt.j2",
+        "LICENSE": "product/product_LICENSE.j2",
+        "package.json": "product/product_package.json.j2",
+        ".gitignore": "product/product_.gitignore.j2",
+        f"src/{name}/__init__.py": "product/product_init.py.j2",
+
+    }
+
+    for rel_path, tpl in files_and_templates.items():
+        abs_path = os.path.join(base_path, rel_path)
+        if tpl:
+            render_and_write_file(env, tpl, abs_path, context)
+        else:
+            if features_file:
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                shutil.copy(features_file, abs_path)
+                
+    # Cambiar permisos y propietario
+    uid = 1000
+    gid = 1000
+
+    os.chown(base_path, uid, gid)
+    os.chmod(base_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH)
+
+    for root, dirs, files in os.walk(base_path):
+        for d in dirs:
+            dir_path = os.path.join(root, d)
+            os.chown(dir_path, uid, gid)
+            os.chmod(dir_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH)
+        for f in files:
+            file_path = os.path.join(root, f)
+            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"✅ Product '{name}' created successfully in {base_path}", fg="green"))

{splent_cli-0.0.1 → splent_cli-0.0.2/src}/splent_cli/commands/selenium.py

@@ -56,7 +56,7 @@ def selenium(module):
     if module:
         validate_module(module)
 
-    if working_dir == "/app/":
+    if working_dir == "/workspace/":
 
         click.echo(
             click.style(

splent_cli-0.0.2/src/splent_cli/commands/webpack_compile.py

@@ -0,0 +1,62 @@
+import logging
+import click
+import os
+import subprocess
+
+from splent_cli.utils.path_utils import PathUtils
+
+logger = logging.getLogger(__name__)
+
+FEATURES_FILE = PathUtils.get_features_file()
+
+
+def get_features():
+    if not os.path.isfile(FEATURES_FILE):
+        return []
+    with open(FEATURES_FILE) as f:
+        return [line.strip() for line in f if line.strip()]
+
+
+@click.command("webpack:compile", help="Compile webpack for one or all features.")
+@click.argument("feature_name", required=False)
+@click.option("--watch", is_flag=True, help="Enable watch mode for development.")
+def webpack_compile(feature_name, watch):
+    production = os.getenv("FLASK_ENV", "develop") == "production"
+
+    def normalize_feature_name(name):
+        return name if name.startswith("splent_feature_") else f"splent_feature_{name}"
+
+    features = (
+        [normalize_feature_name(feature_name)]
+        if feature_name
+        else get_features()
+    )
+
+    for feature in features:
+        compile_feature(feature, watch, production)
+
+
+def compile_feature(feature, watch, production):
+    webpack_file = os.path.join("/workspace", feature, "src", feature, "assets", "js", "webpack.config.js")
+
+    if not os.path.exists(webpack_file):
+        click.echo(click.style(f"⚠ No webpack.config.js found in {feature}, skipping...", fg="yellow"))
+        return
+
+    click.echo(click.style(f"🚀 Compiling {feature}...", fg="cyan"))
+
+    mode = "production" if production else "development"
+    extra_flags = "--devtool source-map --no-cache" if not production else ""
+    watch_flag = "--watch" if watch and not production else ""
+
+    webpack_command = f"npx webpack --config {webpack_file} --mode {mode} {watch_flag} {extra_flags} --color"
+
+    try:
+        if watch:
+            subprocess.Popen(webpack_command, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            click.echo(click.style(f"👀 Watching {feature} in {mode} mode...", fg="blue"))
+        else:
+            subprocess.run(webpack_command, shell=True, check=True)
+            click.echo(click.style(f"✅ Successfully compiled {feature} in {mode} mode!", fg="green"))
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"❌ Error compiling {feature}: {e}", fg="red"))