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

{splent_cli-1.44.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.44.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.44.0 → splent_cli-1.45.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.44.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.44.0 → splent_cli-1.45.0}/src/splent_cli/cli.py

@@ -199,6 +199,12 @@ 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.

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

@@ -6,16 +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
 

{splent_cli-1.44.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.44.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.44.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.44.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,
             )

{splent_cli-1.44.0 → splent_cli-1.45.0}/src/splent_cli/commands/feature/feature_release.py

@@ -196,6 +196,35 @@ def _extract_registered_services(init_path: Path) -> list[str]:
     )
 
 
+def _extract_registered_providers(init_path: Path) -> list[str]:
+    """Classes handed to another feature's ``register_<kind>_provider(app, X)``.
+
+    dataset's register_deposition_provider and captcha's
+    register_captcha_provider put the class in the service locator for the
+    feature that calls them (zenodo, recaptcha), so it is a service that
+    feature provides, as one it registers with register_service is. Only a
+    class named in the call counts, not one built there.
+    """
+    if not init_path.exists():
+        return []
+    try:
+        tree = ast.parse(init_path.read_text())
+    except (SyntaxError, OSError, UnicodeDecodeError):
+        return []
+    found: set[str] = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call) or len(node.args) < 2:
+            continue
+        name = _call_name(node).rsplit(".", 1)[-1]
+        provider = node.args[1]
+        if _PROVIDER_REGISTRATION.fullmatch(name) and isinstance(provider, ast.Name):
+            found.add(provider.id)
+    return sorted(found)
+
+
+_PROVIDER_REGISTRATION = re.compile(r"register_\w+_provider")
+
+
 def _extract_templates(src_dir: Path) -> list[str]:
     templates_dir = src_dir / "templates"
     if not templates_dir.exists():
@@ -867,13 +896,16 @@ def _scan_dependencies(
         except SyntaxError:
             tree = None
         if tree is not None:
+            # An import inside a try that carries on without the module is an
+            # optional dependency (_extract_guarded_imports), not a hard one.
+            guarded = _guarded_ranges(tree, _IMPORT_TOLERANT_HANDLERS)
             imported: list[str] = []
             for node in ast.walk(tree):
-                if isinstance(node, ast.Import):
-                    imported.extend(alias.name for alias in node.names)
-                elif isinstance(node, ast.ImportFrom):
-                    imported.append(node.module or "")
-                    imported.extend(alias.name for alias in node.names)
+                if not isinstance(node, (ast.Import, ast.ImportFrom)):
+                    continue
+                if _in_ranges(node.lineno, guarded):
+                    continue
+                imported.extend(_imported_names(node))
         else:
             # Unparseable file: the line scan, on the code alone.
             imported = [
@@ -899,6 +931,38 @@ def _scan_dependencies(
     return sorted(required_features), sorted(env_vars)
 
 
+def _imported_names(node) -> list[str]:
+    """The dotted names an import statement mentions."""
+    if isinstance(node, ast.Import):
+        return [alias.name for alias in node.names]
+    return [node.module or "", *(alias.name for alias in node.names)]
+
+
+def _extract_guarded_imports(src_dir: Path, own_feature_name: str) -> set[str]:
+    """Other features an import statement names only inside a tolerant try.
+
+    ``try: from splent_io.splent_feature_x import y`` with a handler that
+    catches ``ImportError`` (``ModuleNotFoundError``, ``Exception``, a bare
+    ``except``) and carries on is the static spelling of the optional
+    import :func:`_extract_dynamic_imports` reads. The same statement
+    outside such a try fails without the feature, so it stays a hard
+    requirement there (:func:`_scan_dependencies`).
+    """
+    found: set[str] = set()
+    for _, tree in _parsed_sources(src_dir):
+        guarded = _guarded_ranges(tree, _IMPORT_TOLERANT_HANDLERS)
+        for node in ast.walk(tree):
+            if not isinstance(node, (ast.Import, ast.ImportFrom)):
+                continue
+            if not _in_ranges(node.lineno, guarded):
+                continue
+            for item in _imported_names(node):
+                for short in re.findall(r"splent_feature_(\w+)", item):
+                    if f"splent_feature_{short}" != own_feature_name:
+                        found.add(short)
+    return found
+
+
 def _extract_service_proxies(src_dir: Path) -> tuple[set[str], set[str]]:
     """Service class names looked up via ``service_proxy("XService")``,
     split into ``(hard, soft)`` dependencies.
@@ -1224,6 +1288,8 @@ def build_service_map(workspace: str) -> dict[str, str]:
         for init_path in feature_dir.glob(f"src/*/{dir_name}/__init__.py"):
             for svc in _extract_registered_services(init_path):
                 _add(svc, short)
+            for svc in _extract_registered_providers(init_path):
+                _add(svc, short)
 
         try:
             data = tomllib.loads(py_path.read_text())
@@ -1420,6 +1486,7 @@ def infer_contract(
     services = sorted(
         set(_extract_services(src_dir / "services.py"))
         | set(_extract_registered_services(src_dir / "__init__.py"))
+        | set(_extract_registered_providers(src_dir / "__init__.py"))
     )
     templates = _extract_templates(src_dir)
     template_hook_slots = _extract_template_hook_slots(src_dir)
@@ -1495,6 +1562,7 @@ def infer_contract(
         slot_map = _default_map(build_slot_map)
     candidates = {service_map.get(svc) for svc in soft_proxies - own_services}
     candidates |= soft_imports
+    candidates |= _extract_guarded_imports(src_dir, feature_name)
     candidates |= {
         signal_map.get(name)
         for name in _extract_calls_named(src_dir, "connect_signal")
@@ -1581,6 +1649,87 @@ def _sections_not_owned_by_the_contract(tail: str) -> str:
     return "\n\n".join(kept)
 
 
+_KEY_LINE = re.compile(r"^\s*([A-Za-z0-9_-]+|\"[^\"]*\")\s*=(.*)$")
+
+
+def _inline_comment(rest: str) -> str:
+    """The comment after a value written on one line, ``""`` without one.
+
+    ``rest`` is what follows the ``=``. A ``#`` inside a string is not a
+    comment, so the cut is the first one before which the value parses.
+    """
+    for index, char in enumerate(rest):
+        if char != "#":
+            continue
+        value = rest[:index].strip()
+        if not value:
+            return ""
+        try:
+            tomllib.loads(f"v = {value}")
+        except tomllib.TOMLDecodeError:
+            continue
+        return rest[index:].strip()
+    return ""
+
+
+def _contract_comments(region: str) -> dict:
+    """The comments a maintainer wrote inside the contract's tables.
+
+    ``{(table, key): (lines above, inline comment)}``, where ``key`` is None
+    for the comments above a subtable's header. The contract is written
+    again from the source, so the comments go with what they are about: the
+    key under or after them in the same table. The banner above
+    ``[tool.splent.contract]`` is the writer's own and is written anyway.
+    """
+    comments: dict = {}
+    table = None
+    above: list[str] = []
+    for line in region.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("["):
+            header = stripped.split("#", 1)[0].strip()
+            if not header.startswith("[tool.splent.contract"):
+                break
+            if above and header != "[tool.splent.contract]":
+                comments[(header, None)] = (above, "")
+            table, above = header, []
+        elif stripped.startswith("#"):
+            above.append(stripped)
+        elif stripped:
+            match = _KEY_LINE.match(line)
+            if match and table is not None:
+                inline = _inline_comment(match.group(2))
+                if above or inline:
+                    comments[(table, match.group(1))] = (above, inline)
+            above = []
+    return comments
+
+
+def _with_comments(block: str, comments: dict) -> str:
+    """BLOCK, the contract as written from the source, with COMMENTS back
+    above and after the keys and subtables they were written for."""
+    if not comments:
+        return block
+    out: list[str] = []
+    table = None
+    for line in block.split("\n"):
+        stripped = line.strip()
+        if stripped.startswith("["):
+            table = stripped
+            above, _ = comments.get((table, None), ([], ""))
+            out.extend(above)
+            out.append(line)
+            continue
+        match = _KEY_LINE.match(line)
+        if match and (table, match.group(1)) in comments:
+            above, inline = comments[(table, match.group(1))]
+            out.extend(above)
+            out.append(f"{line}  {inline}" if inline else line)
+            continue
+        out.append(line)
+    return "\n".join(out)
+
+
 def _toml_value(value) -> str:
     """One value as TOML, escaped: lists inline, everything else via tomli_w.
 
@@ -1726,7 +1875,9 @@ def write_contract(pyproject_path: str, contract: dict, feature_name: str) -> No
     # [tool.splent.config] vanished from five features the moment they were
     # released, silently taking every declared default with them.
     refinement_block = ""
+    comments: dict = {}
     if match:
+        comments = _contract_comments(text[match.start() :])
         preserved = _sections_not_owned_by_the_contract(text[match.start() :])
         if preserved:
             refinement_block = "\n" + preserved + "\n"
@@ -1828,7 +1979,7 @@ def write_contract(pyproject_path: str, contract: dict, feature_name: str) -> No
             f"services = {_toml_value(dc.get('depends_on_services', []))}\n"
         )
 
-    path.write_text(text + contract_block + refinement_block)
+    path.write_text(text + _with_comments(contract_block, comments) + refinement_block)
 
 
 def _commands_help_block(commands_help: dict) -> str: