splent-cli 1.27.0__tar.gz → 1.27.1__tar.gz

{splent_cli-1.27.0/src/splent_cli.egg-info → splent_cli-1.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.27.0
+Version: 1.27.1
 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
@@ -14,7 +14,7 @@ Requires-Dist: packaging>=24.0
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.31.0
-Requires-Dist: splent_framework<2,>=1.16.0
+Requires-Dist: splent_framework<2,>=1.16.1
 Requires-Dist: tomli_w>=1.0.0
 Provides-Extra: dev
 Requires-Dist: setuptools==80.3.1; extra == "dev"

{splent_cli-1.27.0 → splent_cli-1.27.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.27.0"
+version = "1.27.1"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -24,7 +24,7 @@ dependencies = [
     "requests>=2.31.0",
     # The CLI drives the framework (paths, feature order, migrations, the
     # app factory) and only works with the same major version of it.
-    "splent_framework>=1.16.0,<2",
+    "splent_framework>=1.16.1,<2",
     "tomli_w>=1.0.0",
 ]
 

{splent_cli-1.27.0 → splent_cli-1.27.1}/src/splent_cli/commands/database/db_migrate.py

@@ -110,8 +110,7 @@ def _hand_to_directory_owner(path: str) -> None:
     is_flag=True,
     help=(
         "Generate a blank migration (no autogenerate) and keep it for manual "
-        "editing. Required for refinement features that add columns to a base "
-        "feature's table — Alembic cannot autodetect runtime-injected mixins."
+        "editing (data migrations or hand-written changes)."
     ),
 )
 @context.requires_product
@@ -243,7 +242,7 @@ def db_migrate(feature, message, empty):
             )
 
         # A blank migration requested with --empty is intentional: keep it so the
-        # user can fill in upgrade()/downgrade() by hand (e.g. refinement columns).
+        # user can fill in upgrade()/downgrade() by hand (e.g. a data migration).
         if empty:
             if newest:
                 _format_migration(newest)

{splent_cli-1.27.0 → splent_cli-1.27.1}/src/splent_cli/commands/feature/feature_refine.py

@@ -6,7 +6,6 @@ Reads the base feature's contract, presents extensible points,
 and generates the [tool.splent.refinement] section in pyproject.toml.
 """
 
-import ast
 import os
 import re
 import tomllib
@@ -521,137 +520,28 @@ def _scaffold_init(
     return True
 
 
-def _model_table_name(class_name: str) -> str:
-    """Default table name of a model class: CamelCase to snake_case."""
-    return re.sub(r"(?<!^)(?=[A-Z])", "_", class_name).lower()
-
-
-def _own_tables(models_path: str) -> set[str]:
-    """Tables the refiner's own models.py declares (db.Model subclasses).
-
-    ``__tablename__`` wins when it is a string literal; abstract models and
-    mixins (classes that do not subclass db.Model) declare no table.
-    """
-    try:
-        with open(models_path, "r", encoding="utf-8") as f:
-            tree = ast.parse(f.read())
-    except (OSError, SyntaxError, ValueError):
-        return set()
-
-    tables = set()
-    for node in tree.body:
-        if not isinstance(node, ast.ClassDef):
-            continue
-        is_model = any(
-            (isinstance(b, ast.Attribute) and b.attr == "Model")
-            or (isinstance(b, ast.Name) and b.id == "Model")
-            for b in node.bases
-        )
-        if not is_model:
-            continue
-        name = _model_table_name(node.name)
-        abstract = False
-        for stmt in node.body:
-            if not isinstance(stmt, ast.Assign) or not isinstance(
-                stmt.value, ast.Constant
-            ):
-                continue
-            for target in stmt.targets:
-                if not isinstance(target, ast.Name):
-                    continue
-                if target.id == "__tablename__" and isinstance(stmt.value.value, str):
-                    name = stmt.value.value
-                elif target.id == "__abstract__" and stmt.value.value is True:
-                    abstract = True
-        if not abstract:
-            tables.add(name)
-    return tables
-
-
-def _update_env_py(
-    feature_path: str,
-    ns: str,
-    feature_name: str,
-    extend_models: list[tuple[str, str]],
-) -> bool:
-    """Update the feature's migrations/env.py to include refined tables.
-
-    Alembic's autogenerate only detects changes in tables listed in
-    FEATURE_TABLES. Refinement features add columns to tables owned by
-    the base feature, so we need to include those tables explicitly. An
-    explicit set turns the framework's auto-detection off, so the
-    refiner's own tables (from its models.py) are listed as well, and a set
-    written before is merged rather than replaced.
-
-    Returns True when env.py was written. FEATURE_TABLES that is missing,
-    spread over several lines or computed is left alone (False), since
-    rewriting it could lose what the developer put there.
-    """
-    ns_safe = normalize_namespace(ns)
-    pkg_dir = os.path.join(feature_path, "src", ns_safe, feature_name)
-    env_path = os.path.join(pkg_dir, "migrations", "env.py")
-    if not os.path.isfile(env_path):
-        return False
-
-    # CamelCase → snake_case: "Notes" → "notes", "UserProfile" → "user_profile"
-    table_names = {_model_table_name(model_name) for model_name, _ in extend_models}
-    table_names |= _own_tables(os.path.join(pkg_dir, "models.py"))
-
-    with open(env_path, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    pattern = re.compile(r"^FEATURE_TABLES\s*=\s*(set\(\)|\{[^}\n]*\})", re.MULTILINE)
-    match = pattern.search(content)
-    if not match:
-        return False
-    current = match.group(1)
-    if current != "set()":
-        try:
-            existing = ast.literal_eval(current)
-        except (SyntaxError, ValueError):
-            return False
-        if not isinstance(existing, set) or not all(
-            isinstance(t, str) for t in existing
-        ):
-            return False
-        table_names |= existing
-
-    tables_str = ", ".join(f'"{t}"' for t in sorted(table_names))
-    content = (
-        content[: match.start()]
-        + f"FEATURE_TABLES = {{{tables_str}}}"
-        + content[match.end() :]
-    )
-
-    with open(env_path, "w", encoding="utf-8") as f:
-        f.write(content)
-    return True
-
-
 def _extend_migration_scope(
     feature_path: str,
     ns: str,
     feature_name: str,
     extend_models: list[tuple[str, str]],
 ):
-    """Run _update_env_py and say what happened, without claiming an update."""
-    if _update_env_py(feature_path, ns, feature_name, extend_models):
-        click.echo(click.style("  updated:    ", dim=True) + "migrations/env.py")
-        return
+    """Say how the refiner's migrations will cover the columns it injects.
+
+    env.py is not touched. The framework puts in scope the refiner's own
+    tables and the columns its mixins inject into the base tables (with
+    their indexes and foreign keys), whatever FEATURE_TABLES holds: an
+    explicit set only adds tables to that.
+    """
     pkg_dir = os.path.join(feature_path, "src", normalize_namespace(ns), feature_name)
     if not os.path.isfile(os.path.join(pkg_dir, "migrations", "env.py")):
         click.echo(
             click.style("  skipped:    ", dim=True) + "migrations/env.py (not found)"
         )
         return
-    # An explicit FEATURE_TABLES turns auto-detection off, so the refiner's
-    # own tables have to be listed as well as the extended base tables.
-    wanted = {_model_table_name(m) for m, _ in extend_models}
-    wanted |= _own_tables(os.path.join(pkg_dir, "models.py"))
-    tables = ", ".join(f'"{t}"' for t in sorted(wanted))
     click.echo(
         click.style("  kept:       ", dim=True)
-        + f"migrations/env.py (add {tables} to FEATURE_TABLES by hand)"
+        + "migrations/env.py (the framework migrates the columns the mixin injects)"
     )
 
 
@@ -1213,7 +1103,7 @@ def feature_refinement(refiner_name):
     # Clean up scaffold files that are not needed for refinement features
     _clean_scaffold_for_refinement(refiner_path, ns, refiner_name)
 
-    # Update env.py to include refined tables in migration scope
+    # Say how the refiner's migrations cover the columns its mixins inject
     if extend_models:
         _extend_migration_scope(refiner_path, ns, refiner_name, extend_models)
 

{splent_cli-1.27.0 → splent_cli-1.27.1}/src/splent_cli/commands/feature/feature_status.py

@@ -380,13 +380,26 @@ def feature_status(as_json, integrity, do_fix, timeline):
 
         # ── Integrity check ──────────────────────────────────────────
         if integrity or do_fix:
-            from splent_cli.utils.integrity import check_feature_integrity, fix_feature
+            from splent_cli.utils.integrity import (
+                check_feature_integrity,
+                fix_feature,
+                resolve_pip_env,
+            )
 
             click.echo()
             click.secho("  Integrity check", bold=True)
             click.echo(click.style(f"  {'─' * 66}", fg="bright_black"))
 
-            total_ok = total_fail = 0
+            # The pip checks look where the product runs: its web container.
+            pip_env = resolve_pip_env(product, product_path, context.resolve_env())
+            if pip_env["kind"] == "unavailable":
+                click.echo(
+                    click.style(
+                        f"  pip checks not verified, {pip_env['reason']}.", dim=True
+                    )
+                )
+
+            total_ok = total_fail = total_skip = 0
 
             for key, entry in sorted(features.items()):
                 name = entry.get("name", key)
@@ -395,38 +408,58 @@ def feature_status(as_json, integrity, do_fix, timeline):
                 state = entry.get("state", "declared")
 
                 results = check_feature_integrity(
-                    product_path, ns_safe, name, version, state
+                    product_path, ns_safe, name, version, state, pip_env=pip_env
                 )
 
-                has_issues = any(not r["ok"] for r in results)
-                name_color = "red" if has_issues else "green"
+                issues = [r for r in results if r["ok"] is False]
+                skipped = any(r["ok"] is None for r in results)
+                name_color = "red" if issues else "yellow" if skipped else "green"
                 click.echo(f"\n  {click.style(name, fg=name_color, bold=True)}")
 
                 for r in results:
-                    if r["ok"]:
+                    if r["ok"] is True:
                         total_ok += 1
                         click.echo(
                             click.style("    [✔] ", fg="green")
                             + f"{r['check']}: {r['detail']}"
                         )
-                    else:
+                    elif r["ok"] is False:
                         total_fail += 1
                         click.echo(
                             click.style("    [✖] ", fg="red")
                             + f"{r['check']}: {r['detail']}"
                         )
+                    else:
+                        total_skip += 1
+                        click.echo(
+                            click.style(
+                                f"    [-] {r['check']}: {r['detail']}", dim=True
+                            )
+                        )
 
-                if has_issues and do_fix:
-                    issues = [r for r in results if not r["ok"]]
-                    fix_feature(product_path, workspace, ns_safe, name, version, issues)
+                if issues and do_fix:
+                    fix_feature(
+                        product_path,
+                        workspace,
+                        ns_safe,
+                        name,
+                        version,
+                        issues,
+                        pip_env=pip_env,
+                    )
 
             click.echo()
-            if total_fail == 0:
+            if total_fail == 0 and total_skip == 0:
                 click.secho(f"  ✅ All {total_ok} checks passed.", fg="green")
             else:
+                parts = [f"{total_ok} passed"]
+                if total_fail:
+                    parts.append(f"{total_fail} failed")
+                if total_skip:
+                    parts.append(f"{total_skip} not verified")
                 click.secho(
-                    f"  {total_ok} passed, {total_fail} failed.",
-                    fg="red" if total_fail else "green",
+                    f"  {', '.join(parts)}.",
+                    fg="red" if total_fail else "yellow",
                 )
 
     else: