splent-cli 1.43.0__tar.gz → 1.45.0__tar.gz

{splent_cli-1.43.0/src/splent_cli.egg-info → splent_cli-1.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.43.0
+Version: 1.45.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.43.0 → splent_cli-1.45.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.43.0"
+version = "1.45.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

splent_cli-1.45.0/src/splent_cli/__init__.py

@@ -0,0 +1,42 @@
+"""The SPLENT command-line interface."""
+
+import os as _os
+from types import MappingProxyType as _MappingProxyType
+
+# What the operator actually exported, taken before anything reads a .env.
+#
+# This must stay the first thing the package does. cli.py runs load_dotenv(),
+# and so do framework modules it imports (path_utils, configuration), which
+# puts every workspace .env key into os.environ before any command runs. Read
+# afterwards, the shell and the file look identical: env:show could never say
+# "not loaded", env:list never showed "·", and the workspace .env passed for
+# shell values and beat the product's docker/.env. Compare against this
+# instead of os.environ whenever the question is "what did the shell export".
+SHELL_ENV = _MappingProxyType(dict(_os.environ))
+
+
+def _bytecode_away_from_the_working_copies() -> None:
+    """Write root's bytecode outside the workspace.
+
+    A ``docker exec`` into the CLI's container runs as root unless it says
+    ``-u``, and root's __pycache__ directories in the working copies of the
+    CLI, the framework and the features were the ones the owner's next
+    release could not rewrite. Root's go under /tmp instead; everyone else's
+    stay where Python puts them. A PYTHONPYCACHEPREFIX already set wins, and
+    so does a workspace root itself owns. What the CLI runs (pytest, the
+    release build) inherits it through the environment.
+    """
+    import sys
+
+    if sys.pycache_prefix or not hasattr(_os, "geteuid") or _os.geteuid() != 0:
+        return
+    try:
+        owner = _os.stat(_os.environ.get("WORKING_DIR") or "/workspace").st_uid
+    except OSError:
+        return
+    if owner != 0:
+        sys.pycache_prefix = "/tmp/splent-root-pycache"
+        _os.environ.setdefault("PYTHONPYCACHEPREFIX", sys.pycache_prefix)
+
+
+_bytecode_away_from_the_working_copies()

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/cli.py

@@ -5,10 +5,13 @@ import os
 import click
 from dotenv import load_dotenv
 
+from splent_cli.services import context
 from splent_cli.utils.command_loader import load_commands
 
 # From here on os.environ holds the workspace .env as well. What the shell
 # itself exported is splent_cli.SHELL_ENV, taken before this line ran.
+# Nothing exported is replaced, so a SPLENT_APP given to one command beats
+# the selection in the file (context.active_app has the whole rule).
 load_dotenv()
 
 
@@ -122,7 +125,7 @@ class SPLENTCLI(click.Group):
                 app = get_app()
                 with app.app_context():
                     self._own_cmds_cache = own_commands.collect(
-                        os.getenv("SPLENT_APP"), set(self.commands)
+                        context.active_app(), set(self.commands)
                     )
         except Exception as e:
             if debug:
@@ -170,7 +173,7 @@ class SPLENTCLI(click.Group):
         """
         from splent_cli.services import web_container
 
-        product = os.getenv("SPLENT_APP")
+        product = context.active_app()
         if not product or web_container.is_product_container():
             return
         if not web_container.running(web_container.name(product)):
@@ -196,6 +199,18 @@ class SPLENTCLI(click.Group):
             from splent_cli.utils.dynamic_imports import get_app
             from splent_cli.utils.db_utils import check_db_connection
 
+            # The environment a command that boots the app builds it in when
+            # nothing says which (utils.decorators.boots_the_app).
+            boot_env = getattr(command, "boot_env", None)
+            if boot_env:
+                os.environ.setdefault("SPLENT_ENV", boot_env)
+
+            # For another product than the selection the CLI's container stays
+            # on the selection's network (compose.attach_self_to_network), so
+            # what reaches this product's services runs where they are.
+            if context.is_override():
+                self._delegate_to_the_product(ctx)
+
             try:
                 app = get_app()
             except Exception as exc:
@@ -205,7 +220,7 @@ class SPLENTCLI(click.Group):
                 # Only then: where the app builds here, the command runs here
                 # with the tools the CLI image has (ruff formats migrations).
                 self._delegate_to_the_product(ctx)
-                product = os.getenv("SPLENT_APP", "The product")
+                product = context.active_app() or "The product"
                 raise click.ClickException(
                     f"{product}'s features need {missing}, which the product's "
                     "image installs and the CLI's does not.\n"

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/check/check_env.py

@@ -6,15 +6,18 @@ import os
 import sys
 
 import click
-import importlib.metadata
 
+from splent_cli.services import context
 from splent_cli.services.release_gate import pypi_credentials
 from splent_cli.utils import forge
+from splent_cli.utils.running_version import installed_version
 
 
 def _pkg_version(name: str) -> str | None:
+    # The checkout's version for an editable install, as `splent version`
+    # reports it: pip's metadata keeps the version it was installed at.
     try:
-        return importlib.metadata.version(name)
+        return installed_version(name)
     except Exception:
         return None
 
@@ -61,7 +64,7 @@ def check_env():
         _warn(".env file not found in workspace")
 
     # SPLENT_APP
-    app = os.getenv("SPLENT_APP")
+    app = context.active_app(workspace)
     if app:
         app_path = os.path.join(workspace, app)
         if os.path.isdir(app_path):

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/clear/clear_uploads.py

@@ -99,7 +99,7 @@ def resolve_uploads_dir(app=None) -> str:
     product or its package, anything holding one of them, or a directory with
     code at its top.
     """
-    product = os.getenv("SPLENT_APP", "")
+    product = context.active_app() or ""
     if not product or product in (".", "..") or os.sep in product or "/" in product:
         raise UploadsDirError(f"'{product}' is not a valid product name.")
 
@@ -279,7 +279,7 @@ def clear_uploads(env_dev, env_prod, yes):
         click.echo(click.style("Cannot specify both --dev and --prod.", fg="red"))
         raise SystemExit(1)
     env = context.resolve_env(env_dev, env_prod)
-    _run_where_the_uploads_are(os.getenv("SPLENT_APP", ""), env, yes)
+    _run_where_the_uploads_are(context.active_app() or "", env, yes)
 
     try:
         uploads_dir = resolve_uploads_dir()

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/database/db_reset.py

@@ -199,7 +199,7 @@ def db_reset(feature_name, yes):
     """
     app = current_app
     product_path = PathUtils.get_app_base_dir()
-    product_name = os.getenv("SPLENT_APP", "")
+    product_name = context.active_app() or ""
 
     if feature_name:
         _reset_one_feature(app, feature_name, yes, product_path, product_name)

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/database/db_rollback.py

@@ -140,7 +140,7 @@ def _downgrade(directory: str, revision: str) -> None:
 def db_rollback(feature, steps, to_base, cascade):
     app = current_app
     product_path = PathUtils.get_app_base_dir()
-    product_name = os.getenv("SPLENT_APP", "")
+    product_name = context.active_app() or ""
 
     if to_base:
         source = click.get_current_context().get_parameter_source("steps")

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/database/db_seed.py

@@ -23,7 +23,7 @@ def _resolve_feature_order(features_raw: list[str]) -> list[str]:
     feature it refines (the refinement metadata the boot reads), with or
     without a UVL. Features with neither keep their declared order.
     """
-    splent_app = os.getenv("SPLENT_APP", "")
+    splent_app = context.active_app() or ""
     working_dir = os.getenv("WORKING_DIR", "/workspace")
     product_dir = os.path.join(working_dir, splent_app) if splent_app else ""
 
@@ -112,7 +112,7 @@ def _product_seeders(errors):
     They are always loaded, also when a single module is seeded, because
     their ``replaces`` decide which feature seeders may run at all.
     """
-    product = os.getenv("SPLENT_APP", "")
+    product = context.active_app()
     if not product:
         return []
     return _load_seeders(f"{product}.seeders", errors, label="product seeders")
@@ -154,7 +154,7 @@ def get_installed_seeders(specific_module=None):
     )
 
     targets = _module_names(specific_module) if specific_module else None
-    if targets and os.getenv("SPLENT_APP", "") in targets:
+    if targets and context.active_app() in targets:
         return product_seeders, errors
 
     seeders = []

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/database/db_upgrade.py

@@ -79,7 +79,7 @@ def _mark_without_migrations(
 
 def _resolve_product():
     """Return (product_path, product_name) from env."""
-    product = os.getenv("SPLENT_APP", "")
+    product = context.active_app() or ""
     product_path = PathUtils.get_app_base_dir()
     return product_path, product
 

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/doctor.py

@@ -19,6 +19,7 @@ from splent_cli.commands.check.check_product import check_product
 from splent_cli.commands.feature.feature_status import feature_status
 from splent_cli.commands.database.db_status import db_status
 from splent_cli.commands.product.product_containers import product_docker
+from splent_cli.services import context
 
 
 SECTIONS = [
@@ -74,7 +75,7 @@ def _check_workspace_precondition():
     elif not os.path.isdir(wd):
         problems.append(f"WORKING_DIR points to a missing directory: {wd}")
 
-    app = os.getenv("SPLENT_APP")
+    app = context.active_app(workspace)
     if not app:
         problems.append("SPLENT_APP is not set")
     elif not os.path.isdir(os.path.join(workspace, app)):

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/env/env_set.py

@@ -263,3 +263,9 @@ def run_wizard():
             break
         else:
             click.secho("Invalid option. Try again.", fg="red")
+
+
+# The group alone. The loader's fallback registers every command it finds in
+# a module, and found the subcommands too, so `splent forge`, `splent pypi`
+# and `splent github` existed as top-level copies of env:set's.
+cli_command = env_set_group

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/feature/feature_attach.py

@@ -3,6 +3,7 @@ import click
 from splent_cli.services import context, compose
 from splent_cli.utils.feature_utils import (
     drop_feature_entries,
+    entry_matches_feature,
     find_feature_entries,
     hot_reinstall,
     parse_feature_entry,
@@ -160,10 +161,35 @@ def feature_attach(feature_identifier, version, env_scope):
 
     attaching = sorted(declared) != sorted(wanted)
     if attaching:
-        drop_feature_entries(data, feature_name, namespace=namespace_fs)
+        # A list that declares the feature keeps it where it is, so a new pin
+        # does not move the entry away from its neighbours and its comment
+        # to the end of the list (uvlhub's, after each release --attach).
+        # Only a list it is new to gets it at the end, and the lists it
+        # leaves lose it.
+        keep_in_place: dict[str, int] = {}
+        for key, entry in declared:
+            if key in target_keys:
+                at = read_feature_list(data, key).index(entry)
+                keep_in_place[key] = min(at, keep_in_place.get(key, at))
+        drop_feature_entries(
+            data,
+            feature_name,
+            namespace=namespace_fs,
+            keys=tuple(key for key, _ in declared if key not in keep_in_place),
+        )
         for key in target_keys:
             features = read_feature_list(data, key)
-            features.append(full_name)
+            if key in keep_in_place:
+                features = [
+                    entry
+                    for entry in features
+                    if not entry_matches_feature(
+                        entry, feature_name, namespace=namespace_fs
+                    )
+                ]
+                features.insert(keep_in_place[key], full_name)
+            else:
+                features.append(full_name)
             write_features_to_data(data, features, key=key)
 
     # ── PyPI name, when it is not the feature's own ──────────────────

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/feature/feature_compat.py

@@ -259,14 +259,22 @@ def _parse_pyproject_entry(entry: str) -> tuple[str, str, str | None]:
     return ns, name, version or None
 
 
+def _product_reader(product_dir: str, pyproject_path: str | None = None):
+    """The reader of the product's pyproject.toml, or of PYPROJECT_PATH, a
+    candidate pyproject checked in its place (product:validate --pyproject)."""
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    if pyproject_path:
+        return PyprojectReader(pyproject_path)
+    return PyprojectReader.for_product(product_dir)
+
+
 def _resolve_all_product_features(
-    product_dir: str, workspace: str
+    product_dir: str, workspace: str, pyproject_path: str | None = None
 ) -> list[tuple[str, Path]]:
     """Read all features from the product and resolve to (label, path)."""
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
     try:
-        features_raw = PyprojectReader.for_product(product_dir).features
+        features_raw = _product_reader(product_dir, pyproject_path).features
     except FileNotFoundError:
         raise SystemExit("❌ pyproject.toml not found in product.")
 
@@ -435,7 +443,9 @@ def _contract_env(path: Path) -> str | None:
     return data.get("tool", {}).get("splent", {}).get("contract", {}).get("env")
 
 
-def env_scope_findings(workspace: str, product_dir: str) -> list[dict]:
+def env_scope_findings(
+    workspace: str, product_dir: str, pyproject_path: str | None = None
+) -> list[dict]:
     """Features confined to one environment, in a list that installs them in
     the other.
 
@@ -443,9 +453,7 @@ def env_scope_findings(workspace: str, product_dir: str) -> list[dict]:
     list the production image installed them too, phpMyAdmin with autologin
     to the database, and nothing said so.
     """
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
-    reader = PyprojectReader.for_product(product_dir)
+    reader = _product_reader(product_dir, pyproject_path)
     lists = {
         "features": reader.features,
         "features_dev": reader.features_dev,
@@ -501,7 +509,9 @@ def _joins_the_shared_network(compose_file: Path) -> bool:
     return "SPLENT_NETWORK" not in str(spec.get("name", ""))
 
 
-def network_findings(workspace: str, product_dir: str) -> list[dict]:
+def network_findings(
+    workspace: str, product_dir: str, pyproject_path: str | None = None
+) -> list[dict]:
     """Feature services the product cannot reach.
 
     Each product has a network of its own, and a feature's services join it
@@ -509,9 +519,7 @@ def network_findings(workspace: str, product_dir: str) -> list[dict]:
     instead, so the app could not send mail to Mailhog and phpMyAdmin could
     not reach the database, and nothing said why.
     """
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
-    reader = PyprojectReader.for_product(product_dir)
+    reader = _product_reader(product_dir, pyproject_path)
     findings = []
     for entry in reader.features + reader.features_dev + reader.features_prod:
         ns, name, version = _parse_pyproject_entry(entry)
@@ -537,14 +545,14 @@ def network_findings(workspace: str, product_dir: str) -> list[dict]:
     return findings
 
 
-def naming_findings(workspace: str, product_dir: str) -> list[dict]:
+def naming_findings(
+    workspace: str, product_dir: str, pyproject_path: str | None = None
+) -> list[dict]:
     """Features named after a product (auth_uvlhub). A warning, so the debt
     shows in every validation until the product drops them."""
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
     from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
 
-    reader = PyprojectReader.for_product(product_dir)
+    reader = _product_reader(product_dir, pyproject_path)
     findings = []
     for entry in reader.features + reader.features_dev + reader.features_prod:
         _, name, _ = _parse_pyproject_entry(entry)
@@ -688,16 +696,14 @@ def version_floor_findings(labeled_paths: list[tuple[str, Path]]) -> list[dict]:
 
 
 def _environment_only_features(
-    product_dir: str, workspace: str, env: str | None
+    product_dir: str, workspace: str, env: str | None, pyproject_path: str | None = None
 ) -> list[tuple[str, Path]]:
     """The features ``features_<env>`` adds to the base list, resolved."""
-    from splent_framework.utils.pyproject_reader import PyprojectReader
-
     env = context.normalize_env(env)
     if not env:
         return []
     try:
-        reader = PyprojectReader.for_product(product_dir)
+        reader = _product_reader(product_dir, pyproject_path)
         base = set(reader.features)
         extra = [e for e in reader.features_for_env(env) if e not in base]
     except (FileNotFoundError, ValueError):
@@ -706,7 +712,10 @@ def _environment_only_features(
 
 
 def run_all_product_check(
-    workspace: str, product_dir: str, env: str | None = None
+    workspace: str,
+    product_dir: str,
+    env: str | None = None,
+    pyproject_path: str | None = None,
 ) -> list[dict]:
     """Run the full product compatibility check. Returns findings list.
 
@@ -714,9 +723,13 @@ def run_all_product_check(
     floors are checked across the features the product loads in ``env``
     (SPLENT_ENV when None, ``dev`` when that is unset too), base plus
     ``features_dev`` or ``features_prod``, the selection phase 1 checks.
+    ``pyproject_path`` names a candidate pyproject to read the features
+    from instead of the product's.
     """
     try:
-        labeled_paths = _resolve_all_product_features(product_dir, workspace)
+        labeled_paths = _resolve_all_product_features(
+            product_dir, workspace, pyproject_path
+        )
     except SystemExit:
         return []
     if not labeled_paths:
@@ -725,7 +738,8 @@ def run_all_product_check(
         env = os.getenv("SPLENT_ENV") or "dev"
     labeled_contracts = [(lbl, _read_contract(path)) for lbl, path in labeled_paths]
     findings = _analyse_all(labeled_contracts) + version_floor_findings(
-        labeled_paths + _environment_only_features(product_dir, workspace, env)
+        labeled_paths
+        + _environment_only_features(product_dir, workspace, env, pyproject_path)
     )
     return sorted(findings, key=lambda f: SEVERITY_ORDER[f["severity"]])
 

{splent_cli-1.43.0 → splent_cli-1.45.0}/src/splent_cli/commands/feature/feature_contract.py

@@ -21,6 +21,7 @@ from pathlib import Path
 
 from splent_cli.services import context
 from splent_cli.commands.feature.feature_release import (
+    _interactive,
     infer_contract,
     merge_preserved,
     requirement_problems,
@@ -341,8 +342,16 @@ def _print_diff(current: dict, inferred: dict) -> bool:
     is_flag=True,
     help="Write the inferred contract to pyproject.toml (default: dry-run only).",
 )
+@click.option(
+    "--inject-config/--no-inject-config",
+    "inject_config",
+    default=None,
+    help="With --write, run feature:inject-config when config.py is missing or "
+    "lacks a variable, without asking. Without a terminal and without either "
+    "flag it is not run.",
+)
 @context.requires_product
-def feature_contract(feature_ref, write):
+def feature_contract(feature_ref, write, inject_config):
     """
     Infer the feature contract from source code at any time during development.
 
@@ -362,6 +371,12 @@ def feature_contract(feature_ref, write):
     which a product's config.py may set. The keys of Flask, the framework,
     the extensions it sets up and other features are left out.
 
+    \b
+    When --write finds config.py missing, or missing a variable the feature
+    reads, it offers feature:inject-config. --inject-config runs it without
+    asking and --no-inject-config never does; without a terminal and
+    without either flag it is not run, and the command says how to run it.
+
     \b
     FEATURE_REF is a short name (notes), a package name
     (splent_feature_notes), either one under a namespace (splent-io/notes),
@@ -482,7 +497,7 @@ def feature_contract(feature_ref, write):
     click.secho("  ✅ Contract written to pyproject.toml.", fg="green")
 
     # Check if config.py needs updating
-    _check_config_py(cache_path, ns, name, inferred)
+    _check_config_py(cache_path, ns, name, inferred, inject_config)
 
     # And whether the settings it reads are declared where a product looks
     _check_declared_config(cache_path, inferred)
@@ -637,8 +652,29 @@ def _report_params(feature_path, name):
         )
 
 
-def _check_config_py(feature_path, ns, name, inferred):
-    """Warn if config.py is missing or stale relative to the inferred contract."""
+def _wants_inject_config(question: str, name: str, inject: bool | None) -> bool:
+    """Whether to run feature:inject-config: the flag when one was given,
+    else the answer to QUESTION. Without a terminal nobody can answer, and
+    click.confirm aborted the whole command after the contract was written,
+    so it is not asked and not run."""
+    if inject is not None:
+        return inject
+    if not _interactive():
+        click.secho(
+            f"     Not asked without a terminal. Run 'splent feature:inject-config "
+            f"{name}', or pass --inject-config.",
+            dim=True,
+        )
+        return False
+    return click.confirm(question, default=True)
+
+
+def _check_config_py(feature_path, ns, name, inferred, inject=None):
+    """Warn if config.py is missing or stale relative to the inferred contract.
+
+    ``inject`` is --inject-config (True), --no-inject-config (False) or
+    neither (None), see :func:`_wants_inject_config`.
+    """
     from splent_cli.commands.feature.feature_inject_config import (
         _is_regenerable,
         read_config_env_vars,
@@ -660,8 +696,8 @@ def _check_config_py(feature_path, ns, name, inferred):
             f"  ⚠  config.py not found — {len(env_vars)} env var(s) detected but not injected into app.config.",
             fg="yellow",
         )
-        if click.confirm(
-            "     Run feature:inject-config to generate it?", default=True
+        if _wants_inject_config(
+            "     Run feature:inject-config to generate it?", name, inject
         ):
             from splent_cli.commands.feature.feature_inject_config import (
                 feature_inject_config,
@@ -691,7 +727,9 @@ def _check_config_py(feature_path, ns, name, inferred):
                 dim=True,
             )
             return
-        if click.confirm("     Run feature:inject-config to update it?", default=True):
+        if _wants_inject_config(
+            "     Run feature:inject-config to update it?", name, inject
+        ):
             from splent_cli.commands.feature.feature_inject_config import (
                 feature_inject_config,
             )