splent-cli 1.9.2__tar.gz → 1.11.0__tar.gz

{splent_cli-1.9.2/src/splent_cli.egg-info → splent_cli-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.9.2
+Version: 1.11.0
 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
@@ -11,6 +11,7 @@ License-File: LICENSE
 Requires-Dist: click==8.1.8
 Requires-Dist: packaging>=24.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: tomli_w>=1.0.0
 Provides-Extra: dev
 Requires-Dist: setuptools==80.3.1; extra == "dev"
 Requires-Dist: pytest==8.3.4; extra == "dev"

{splent_cli-1.9.2 → splent_cli-1.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.9.2"
+version = "1.11.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -15,6 +15,7 @@ dependencies = [
     "click==8.1.8",
     "packaging>=24.0",
     "requests>=2.31.0",
+    "tomli_w>=1.0.0",
 ]
 
 [project.optional-dependencies]
@@ -62,8 +63,11 @@ where = ["src"]
 testpaths = ["tests"]
 pythonpath = ["src"]
 
-[tool.black]
-line-length = 79
+# Canonical formatter/linter is Ruff (`splent lint` runs `ruff check` +
+# `ruff format`). Ruff's default line length (88) is the project standard;
+# set explicitly here so it is unambiguous.
+[tool.ruff]
+line-length = 88
 
 [project.urls]
 Homepage = "https://github.com/diverso-lab/splent_cli"

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/check/check_features.py

@@ -54,8 +54,15 @@ def check_features():
         _fail("pyproject.toml not found")
         raise SystemExit(1)
 
-    with open(pyproject_path, "rb") as f:
-        data = tomllib.load(f)
+    try:
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        _fail(f"pyproject.toml is not valid TOML: {e}")
+        raise SystemExit(1)
+    except OSError as e:
+        _fail(f"Could not read pyproject.toml: {e}")
+        raise SystemExit(1)
 
     env = os.getenv("SPLENT_ENV")
     features = read_features_from_data(data, env)

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/check/check_infra.py

@@ -7,18 +7,43 @@ import subprocess
 import json
 
 import click
-import tomllib
 
 from splent_cli.services import context, compose
 from splent_cli.utils.feature_utils import read_features_from_data
+from splent_cli.utils.io_utils import load_toml
+
+
+class _Result:
+    """Minimal stand-in for CompletedProcess used by the guarded ``_run``."""
+
+    __slots__ = ("returncode", "stdout", "stderr")
+
+    def __init__(self, returncode: int, stdout: str = "", stderr: str = ""):
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+def _run(cmd: list) -> _Result:
+    """Run a docker command, never crashing the diagnostic.
+
+    Missing tool (FileNotFoundError) and timeouts are mapped to a non-zero
+    returncode so callers treat them as a normal FAIL/skip, exactly like
+    check_docker._run.
+    """
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        return _Result(r.returncode, r.stdout, r.stderr)
+    except FileNotFoundError:
+        return _Result(1, "", "command not found")
+    except subprocess.TimeoutExpired:
+        return _Result(1, "", "timed out")
 
 
 def _parse_compose_ports(compose_file: str) -> list[tuple[int, str, str]]:
     """Return [(host_port, service_name, source_label)] from a compose file."""
-    result = subprocess.run(
-        ["docker", "compose", "-f", compose_file, "config", "--format", "json"],
-        capture_output=True,
-        text=True,
+    result = _run(
+        ["docker", "compose", "-f", compose_file, "config", "--format", "json"]
     )
     if result.returncode != 0:
         return []
@@ -41,10 +66,8 @@ def _parse_compose_ports(compose_file: str) -> list[tuple[int, str, str]]:
 
 def _parse_compose_services(compose_file: str) -> list[tuple[str, str, str]]:
     """Return [(service_name, container_name_or_None, source_label)]."""
-    result = subprocess.run(
-        ["docker", "compose", "-f", compose_file, "config", "--format", "json"],
-        capture_output=True,
-        text=True,
+    result = _run(
+        ["docker", "compose", "-f", compose_file, "config", "--format", "json"]
     )
     if result.returncode != 0:
         return []
@@ -97,8 +120,7 @@ def check_infra():
         _fail("pyproject.toml not found")
         raise SystemExit(1)
 
-    with open(pyproject_path, "rb") as f:
-        data = tomllib.load(f)
+    data = load_toml(pyproject_path, what="pyproject.toml")
 
     env = os.getenv("SPLENT_ENV", "dev")
     features = read_features_from_data(data, env)
@@ -132,21 +154,19 @@ def check_infra():
     else:
         _ok(f"No port conflicts ({len(all_ports)} ports declared)")
 
-    # Check against running containers
+    # Check against running containers (query docker ps once, not per-port)
     running_conflicts = []
-    for port in all_ports:
-        result = subprocess.run(
-            ["docker", "ps", "--format", "{{.ID}}\t{{.Names}}\t{{.Ports}}"],
-            capture_output=True,
-            text=True,
-        )
-        for line in result.stdout.splitlines():
-            parts = line.split("\t", 2)
-            if len(parts) < 3:
-                continue
-            cid, name, ports_str = parts
-            if f":{port}->" in ports_str:
-                running_conflicts.append((port, name))
+    ps_result = _run(["docker", "ps", "--format", "{{.ID}}\t{{.Names}}\t{{.Ports}}"])
+    if ps_result.returncode == 0:
+        ps_lines = ps_result.stdout.splitlines()
+        for port in all_ports:
+            for line in ps_lines:
+                parts = line.split("\t", 2)
+                if len(parts) < 3:
+                    continue
+                cid, name, ports_str = parts
+                if f":{port}->" in ports_str:
+                    running_conflicts.append((port, name))
 
     if running_conflicts:
         for port, cname in running_conflicts:
@@ -189,11 +209,7 @@ def check_infra():
     click.echo(click.style("  Networks", bold=True))
     required_networks: set[str] = set()
     for label, cf in compose_files:
-        result = subprocess.run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"],
-            capture_output=True,
-            text=True,
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:
@@ -205,10 +221,8 @@ def check_infra():
                 required_networks.add(net_name)
 
     if required_networks:
-        existing_networks = subprocess.run(
-            ["docker", "network", "ls", "--format", "{{.Name}}"],
-            capture_output=True,
-            text=True,
+        existing_networks = _run(
+            ["docker", "network", "ls", "--format", "{{.Name}}"]
         ).stdout.splitlines()
         for net in sorted(required_networks):
             if net in existing_networks:
@@ -226,11 +240,7 @@ def check_infra():
     build_count = 0
     for label, cf in compose_files:
         docker_dir = os.path.dirname(cf)
-        result = subprocess.run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"],
-            capture_output=True,
-            text=True,
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:
@@ -268,11 +278,7 @@ def check_infra():
     services_depended_on: dict[str, str] = {}  # depended_svc -> by_svc
 
     for label, cf in compose_files:
-        result = subprocess.run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"],
-            capture_output=True,
-            text=True,
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:
@@ -309,11 +315,7 @@ def check_infra():
     click.echo(click.style("  Volumes", bold=True))
     all_volumes: dict[str, list[str]] = {}  # vol_name -> [labels]
     for label, cf in compose_files:
-        result = subprocess.run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"],
-            capture_output=True,
-            text=True,
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/coverage.py

@@ -1,8 +1,8 @@
 import click
-import subprocess
 import os
 
 from splent_cli.utils.path_utils import PathUtils
+from splent_cli.utils.proc import run
 from splent_cli.services import context
 
 
@@ -36,9 +36,12 @@ def coverage(module_name, html):
     if html:
         coverage_cmd.extend(["--cov-report", "html"])
 
-    try:
-        subprocess.run(coverage_cmd, check=True)
-    except subprocess.CalledProcessError:
+    result = run(
+        coverage_cmd,
+        check=False,
+        tool_hint="Install it with: pip install pytest pytest-cov",
+    )
+    if result.returncode != 0:
         click.echo(
             click.style("❌ Coverage run failed (tests may be failing).", fg="red")
         )

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/database/db_console.py

@@ -1,9 +1,9 @@
 import click
-import subprocess
 from dotenv import load_dotenv
 import os
 
 from splent_cli.services import context
+from splent_cli.utils.proc import run, require_tool
 
 
 @click.command(
@@ -38,19 +38,34 @@ def db_console():
         )
         raise SystemExit(1)
 
-    try:
-        subprocess.run(
-            [
-                "mysql",
-                f"-h{mariadb_hostname}",
-                f"-u{mariadb_user}",
-                f"-p{mariadb_password}",
-                mariadb_database,
-            ],
-            check=True,
+    require_tool(
+        "mysql",
+        "Install the MariaDB/MySQL client (e.g. 'mariadb-client') and ensure it is on your PATH.",
+    )
+
+    result = run(
+        [
+            "mysql",
+            f"-h{mariadb_hostname}",
+            f"-u{mariadb_user}",
+            f"-p{mariadb_password}",
+            mariadb_database,
+        ],
+        check=False,
+    )
+    if result.returncode != 0:
+        click.secho(
+            f"❌ Could not open the MariaDB console (mysql exited {result.returncode}).",
+            fg="red",
+        )
+        click.secho(
+            "   Is the database container running and reachable?\n"
+            f"   Tried to connect to host '{mariadb_hostname}' as user "
+            f"'{mariadb_user}'.\n"
+            "   Start it with: splent product:up   (or check 'docker ps').",
+            fg="yellow",
         )
-    except subprocess.CalledProcessError as e:
-        click.secho(f"❌ Error opening MariaDB console: {e}", fg="red")
+        raise SystemExit(1)
 
 
 cli_command = db_console

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/database/db_dump.py

@@ -1,10 +1,11 @@
 import click
-import subprocess
 from dotenv import load_dotenv
 import os
+import tempfile
 from datetime import datetime
 
 from splent_cli.services import context
+from splent_cli.utils.proc import run, require_tool
 
 
 @click.command(
@@ -44,10 +45,23 @@ def db_dump(filename):
         if not filename.endswith(".sql"):
             filename += ".sql"
 
+    require_tool(
+        "mysqldump",
+        "Install the MariaDB/MySQL client tools (provides 'mysqldump').",
+    )
+
+    env = {**os.environ, "MYSQL_PWD": mariadb_password or ""}
+
+    # Dump to a temp file first and only replace the target on success, so a
+    # pre-existing file with the same name is never truncated or deleted if the
+    # dump fails midway.
+    target_dir = os.path.dirname(os.path.abspath(filename)) or "."
+    fd, tmp_path = tempfile.mkstemp(
+        prefix=".db_dump_", suffix=".sql.tmp", dir=target_dir
+    )
     try:
-        env = {**os.environ, "MYSQL_PWD": mariadb_password or ""}
-        with open(filename, "wb") as out:
-            subprocess.run(
+        with os.fdopen(fd, "wb") as out:
+            run(
                 [
                     "mysqldump",
                     f"-h{mariadb_hostname}",
@@ -55,17 +69,18 @@ def db_dump(filename):
                     mariadb_database,
                 ],
                 stdout=out,
-                check=True,
+                text=False,
                 env=env,
+                tool_hint="Install the MariaDB/MySQL client tools (provides 'mysqldump').",
             )
+        os.replace(tmp_path, filename)
         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"))
-        if os.path.exists(filename):
-            os.remove(filename)
-            click.echo(click.style(f"Partial file removed: {filename}", fg="yellow"))
+    except BaseException:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        raise
 
 
 cli_command = db_dump

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/database/db_migrate.py

@@ -75,9 +75,7 @@ def db_migrate(feature, message, empty):
     and kept so you can write ``upgrade()``/``downgrade()`` by hand.
     """
     if empty and not feature:
-        click.echo(
-            click.style("❌ --empty requires a FEATURE argument.", fg="red")
-        )
+        click.echo(click.style("❌ --empty requires a FEATURE argument.", fg="red"))
         raise SystemExit(1)
 
     if feature:
@@ -125,19 +123,39 @@ def db_migrate(feature, message, empty):
         prev_level = alembic_logger.level
         alembic_logger.setLevel(logging.WARNING)
 
+        gen_error = None
         try:
             if empty:
                 alembic_revision(directory=mdir, message=message or feat)
             else:
                 alembic_migrate(directory=mdir, message=message or feat)
         except Exception as e:
-            if os.getenv("SPLENT_DEBUG"):
-                click.secho(
-                    f"  ⚠️  {feat}: migration generation skipped ({e})", fg="yellow"
-                )
+            gen_error = e
         finally:
             alembic_logger.setLevel(prev_level)
 
+        # Always surface generation failures — never report "up to date" when the
+        # migration actually failed to generate. Show a one-line error (full
+        # detail only under SPLENT_DEBUG).
+        if gen_error is not None:
+            click.echo(
+                click.style(
+                    f"  ❌ {feat}: migration generation failed ({gen_error})",
+                    fg="red",
+                )
+            )
+            if os.getenv("SPLENT_DEBUG"):
+                import traceback
+
+                click.echo(
+                    "".join(
+                        traceback.format_exception(
+                            type(gen_error), gen_error, gen_error.__traceback__
+                        )
+                    )
+                )
+            continue
+
         after = _count_versions(mdir)
 
         # A blank migration requested with --empty is intentional: keep it so the

{splent_cli-1.9.2 → splent_cli-1.11.0}/src/splent_cli/commands/database/db_reset.py

@@ -41,9 +41,14 @@ def db_reset(yes):
         return
 
     # --- STEP 1: Drop ALL tables (including alembic_* and splent_migrations) ---
+    # Run every DROP inside a single transaction (engine.begin) so that a
+    # mid-operation connection failure rolls back as a unit rather than
+    # leaving a half-dropped schema. Note: MySQL/MariaDB issue an implicit
+    # COMMIT on DDL, so a full rollback is not guaranteed there; we therefore
+    # also surface explicit partial-state recovery guidance on failure.
     click.echo(click.style("🗑️  Dropping all tables...", fg="yellow"))
     try:
-        with db.engine.connect() as conn:
+        with db.engine.begin() as conn:
             conn.execute(text("SET FOREIGN_KEY_CHECKS = 0"))
             meta = MetaData()
             meta.reflect(bind=db.engine)
@@ -51,11 +56,21 @@ def db_reset(yes):
                 conn.execute(text(f"DROP TABLE IF EXISTS `{table.name}`"))
                 click.echo(click.style(f"   Dropped {table.name}", fg="bright_black"))
             conn.execute(text("SET FOREIGN_KEY_CHECKS = 1"))
-            conn.commit()
         click.echo(click.style("✅ All tables dropped.", fg="yellow"))
     except Exception as e:
         click.echo(click.style(f"❌ Error dropping tables: {e}", fg="red"))
-        return
+        click.echo(
+            click.style(
+                "⚠️  The database may now be in a PARTIAL state: some tables "
+                "may have been dropped while others remain.\n"
+                "   To recover, re-run this command once the database is "
+                "reachable again (it is safe to repeat — drops use "
+                "DROP TABLE IF EXISTS), or manually drop the remaining "
+                "tables / re-create the schema from migrations.",
+                fg="red",
+            )
+        )
+        raise SystemExit(1)
 
     # --- STEP 2: Recreate splent_migrations tracking table ---
     click.echo(click.style("📋 Recreating splent_migrations table...", fg="cyan"))
@@ -74,7 +89,15 @@ def db_reset(yes):
             )
     except Exception as e:
         click.echo(click.style(f"❌ Error creating tracking table: {e}", fg="red"))
-        return
+        click.echo(
+            click.style(
+                "⚠️  All tables were dropped but the tracking table could not "
+                "be recreated. Re-run this command once the database is "
+                "reachable to finish the reset.",
+                fg="red",
+            )
+        )
+        raise SystemExit(1)
 
     # --- STEP 3: Clear uploads ---
     ctx = click.get_current_context()

splent_cli-1.11.0/src/splent_cli/commands/database/db_restore.py

@@ -0,0 +1,117 @@
+import os
+import click
+from datetime import datetime
+from dotenv import load_dotenv
+
+from splent_cli.services import context
+from splent_cli.utils.proc import run
+
+
+@click.command(
+    "db:restore",
+    short_help="Restore a MariaDB database from a SQL dump file.",
+)
+@click.argument("filename")
+@click.option("--yes", is_flag=True, help="Skip confirmation prompt.")
+@context.requires_product
+def db_restore(filename, yes):
+    """
+    Restore the database from FILENAME (a .sql dump).
+
+    Reads connection credentials from the workspace .env file
+    (MARIADB_HOSTNAME, MARIADB_USER, MARIADB_PASSWORD, MARIADB_DATABASE).
+
+    \b
+    Example:
+        splent db:restore dump_20250101_120000.sql
+    """
+    load_dotenv()
+
+    if not os.path.exists(filename):
+        click.secho(f"❌ File not found: {filename}", fg="red")
+        raise SystemExit(1)
+
+    host = os.getenv("MARIADB_HOSTNAME")
+    user = os.getenv("MARIADB_USER")
+    password = os.getenv("MARIADB_PASSWORD")
+    database = os.getenv("MARIADB_DATABASE")
+
+    missing = [
+        k
+        for k, v in {
+            "MARIADB_HOSTNAME": host,
+            "MARIADB_USER": user,
+            "MARIADB_PASSWORD": password,
+            "MARIADB_DATABASE": database,
+        }.items()
+        if not v
+    ]
+
+    if missing:
+        click.secho(f"❌ Missing env vars: {', '.join(missing)}", fg="red")
+        raise SystemExit(1)
+
+    if not yes:
+        click.secho(
+            f"⚠️  This will overwrite the database '{database}' with the contents of '{filename}'.",
+            fg="yellow",
+        )
+        if not click.confirm("Continue?"):
+            click.echo("❎ Cancelled.")
+            raise SystemExit(0)
+
+    env = {**os.environ, "MYSQL_PWD": password or ""}
+
+    # Take an automatic pre-restore backup so a corrupt/partial dump cannot
+    # leave the live database half-overwritten with no way back.
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_filename = f"pre_restore_{database}_{timestamp}.sql"
+    try:
+        with open(backup_filename, "wb") as backup_out:
+            run(
+                ["mysqldump", f"-h{host}", f"-u{user}", database],
+                stdout=backup_out,
+                env=env,
+                tool_hint=(
+                    "Install the MariaDB/MySQL client tools (provides 'mysqldump'), "
+                    "e.g. 'mysql-client' / 'mariadb-client'."
+                ),
+            )
+    except click.ClickException:
+        # mysqldump missing/failed (often a connection failure): do not proceed
+        # to overwrite the live database without a safety net.
+        if os.path.exists(backup_filename):
+            os.remove(backup_filename)
+        click.secho(
+            f"❌ Could not create a pre-restore backup of '{database}' "
+            f"(check the database is reachable at '{host}' and credentials are correct).\n"
+            "Aborting before overwriting the live database.",
+            fg="red",
+        )
+        raise SystemExit(1)
+
+    click.secho(f"🛟 Pre-restore backup saved to: {backup_filename}", fg="cyan")
+
+    try:
+        with open(filename, "rb") as sql_file:
+            run(
+                ["mysql", f"-h{host}", f"-u{user}", database],
+                stdin=sql_file,
+                env=env,
+                tool_hint=(
+                    "Install the MariaDB/MySQL client tools (provides 'mysql'), "
+                    "e.g. 'mysql-client' / 'mariadb-client'."
+                ),
+            )
+        click.secho(f"✅ Database restored from: {filename}", fg="green")
+    except click.ClickException as e:
+        click.secho(f"❌ Error restoring database: {e.format_message()}", fg="red")
+        click.secho(
+            "The database may be in an inconsistent state. To roll back, restore "
+            f"the pre-restore backup:\n  splent db:restore {backup_filename} --yes",
+            fg="yellow",
+        )
+        raise SystemExit(1)
+
+
+cli_command = db_restore