splent-cli 1.34.0__tar.gz → 1.34.1__tar.gz

{splent_cli-1.34.0/src/splent_cli.egg-info → splent_cli-1.34.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.34.0
+Version: 1.34.1
 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.34.0 → splent_cli-1.34.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.34.0"
+version = "1.34.1"
 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.34.0 → splent_cli-1.34.1}/src/splent_cli/commands/feature/feature_create.py

@@ -10,12 +10,9 @@ from splent_cli.utils.feature_utils import (
 )
 from splent_cli.services import context
 
-try:
-    from importlib.metadata import version as _pkg_version
+from splent_cli.utils.running_version import cli_version as _running_cli_version
 
-    _CLI_VERSION = _pkg_version("splent_cli")
-except Exception:
-    _CLI_VERSION = "dev"
+_CLI_VERSION = _running_cli_version()
 
 
 FEATURE_TYPES = ("full", "light", "config", "service")

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/commands/product/product_build.py

@@ -9,6 +9,7 @@ import click
 from splent_cli.services import context, compose, deploy_bundle
 from splent_cli.services.preflight import run_preflight
 from splent_cli.utils.feature_utils import read_features_from_data
+from splent_cli.utils.running_version import cli_version
 from splent_cli.utils.io_utils import (
     atomic_write,
     env_line,
@@ -406,26 +407,6 @@ def framework_version(workspace: str) -> str:
         )
 
 
-def cli_version() -> str:
-    """The version of the CLI that is running, the one the image installs too.
-
-    Read from the source tree it runs from when that is a checkout: an
-    editable install records its version once, when it is installed, and the
-    checkout moves on with every release.
-    """
-    from importlib.metadata import version
-    from pathlib import Path
-
-    import splent_cli
-
-    pyproject = Path(splent_cli.__file__).resolve().parents[2] / "pyproject.toml"
-    if pyproject.is_file():
-        project = load_toml(str(pyproject)).get("project", {})
-        if project.get("name") == "splent_cli" and project.get("version"):
-            return str(project["version"])
-    return version("splent_cli")
-
-
 def runtime_pins(workspace: str) -> dict:
     """{package: version} the production image installs from PyPI."""
     return {

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/commands/product/product_create.py

@@ -20,12 +20,9 @@ from splent_cli.utils.template_drift import (
 )
 from splent_cli.utils.template_drift import _forge_host as _template_forge_host
 
-try:
-    from importlib.metadata import version as _pkg_version
+from splent_cli.utils.running_version import cli_version as _running_cli_version
 
-    _CLI_VERSION = _pkg_version("splent_cli")
-except Exception:
-    _CLI_VERSION = "dev"
+_CLI_VERSION = _running_cli_version()
 
 
 PRODUCT_NAME_RE = re.compile(r"^[a-z_][a-z0-9_]*$")

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/commands/release/release_resume.py

@@ -21,7 +21,7 @@ something is already wrong:
 
 and two more keep what it publishes equal to what the tag says:
 
-  * origin/main only ever receives the commit the tag describes, as a
+  * the release branch on origin only ever receives the commit the tag describes, as a
     fast-forward. A divergence leaves the forge half stuck, never a tag on a
     commit no remote branch contains
   * nothing is built from uncommitted changes, and the Docker image, whose
@@ -153,25 +153,26 @@ def _is_ancestor(path: str, ancestor: str, descendant: str) -> bool:
 
 
 def plan_main_push(path: str, tag: str) -> tuple[str, str | None]:
-    """How origin/main comes to carry the commit *tag* describes.
+    """How the release branch on origin comes to carry the commit *tag* describes.
 
     Returns ``(state, sha)``, where *sha* is the commit that is or will be
     tagged: the tag's commit when the tag exists locally, otherwise HEAD,
     because that is where the tag will be created. Never HEAD when a tag
     exists, since the operator may have committed more work since.
 
-    ``contained``  origin/main already has it, nothing to push
-    ``push``       pushing it is a fast-forward of origin/main
+    ``contained``  origin already has it on the branch, nothing to push
+    ``push``       pushing it is a fast-forward of that branch
     ``diverged``   it is neither, so no tag can be published on it
-    ``unknown``    there is no origin/main to compare with, nothing is pushed
+    ``unknown``    origin has no such branch to compare with, nothing is pushed
     ``timeout``    origin did not answer in time, so nothing can be compared
     """
+    branch = release.release_branch(path)
     ref = (
         f"refs/tags/{tag}^{{commit}}" if release.local_tag_exists(path, tag) else "HEAD"
     )
     try:
         subprocess.run(
-            ["git", "fetch", "origin", "main"],
+            ["git", "fetch", "origin", branch],
             cwd=path,
             capture_output=True,
             env=_non_interactive_env(),
@@ -180,7 +181,7 @@ def plan_main_push(path: str, tag: str) -> tuple[str, str | None]:
     except subprocess.TimeoutExpired:
         return "timeout", _git_out(path, ["rev-parse", "--verify", ref])
     sha = _git_out(path, ["rev-parse", "--verify", ref])
-    remote = _git_out(path, ["rev-parse", "--verify", "refs/remotes/origin/main"])
+    remote = _git_out(path, ["rev-parse", "--verify", f"refs/remotes/origin/{branch}"])
     if not sha or not remote:
         return "unknown", sha
     if sha == remote or _is_ancestor(path, sha, remote):
@@ -191,10 +192,11 @@ def plan_main_push(path: str, tag: str) -> tuple[str, str | None]:
 
 
 def push_commit_to_main(path: str, sha: str) -> str | None:
-    """Fast-forward origin/main to *sha*. None on success, else the reason."""
+    """Fast-forward the release branch on origin to *sha*. None on success, else the reason."""
+    branch = release.release_branch(path)
     try:
         r = subprocess.run(
-            ["git", "push", "origin", f"{sha}:refs/heads/main"],
+            ["git", "push", "origin", f"{sha}:refs/heads/{branch}"],
             cwd=path,
             capture_output=True,
             text=True,
@@ -207,7 +209,7 @@ def push_commit_to_main(path: str, sha: str) -> str | None:
         )
     if r.returncode != 0:
         return (r.stderr or "").strip() or f"git push exited {r.returncode}"
-    click.echo(f"  push     origin/main updated to {sha[:12]}")
+    click.echo(f"  push     origin/{branch} updated to {sha[:12]}")
     return None
 
 
@@ -419,7 +421,7 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
             push_tag = make_release = False
             main_sha = None
             summary = (
-                f"origin/main and the commit {tag} describes have diverged, so "
+                f"origin/{release.release_branch(path)} and the commit {tag} describes have diverged, so "
                 "the tag was not pushed"
                 if main_state == "diverged"
                 else "origin did not answer 'git fetch' within "
@@ -522,7 +524,9 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
 
     steps = []
     if main_sha:
-        steps.append(f"push {main_sha[:12]} to origin/main, the commit {tag} describes")
+        steps.append(
+            f"push {main_sha[:12]} to origin/{release.release_branch(path)}, the commit {tag} describes"
+        )
     if upload:
         steps.append(f"build and upload {package} {normalized} to PyPI")
     if push_tag:
@@ -590,9 +594,9 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
             stuck.append(
                 release_gate.ChannelStatus(
                     release_gate.FORGE,
-                    summary=f"could not push {main_sha[:12]} to origin/main, {failure}",
+                    summary=f"could not push {main_sha[:12]} to origin/{release.release_branch(path)}, {failure}",
                     hints=[
-                        "Fix the push to origin/main, then run "
+                        f"Fix the push to origin/{release.release_branch(path)}, then run "
                         f"'splent release:resume {hint_target}' again.",
                     ],
                 )
@@ -604,7 +608,7 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
                     push_image=push_image,
                     summary=f"not built, there is no {tag} to build it from",
                     hint=f"Nothing is built before {tag} exists. Fix the push "
-                    f"to origin/main, then run 'splent release:resume "
+                    f"to origin/{release.release_branch(path)}, then run 'splent release:resume "
                     f"{hint_target}' again.",
                 )
                 upload = push_image = False

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/services/marketplace.py

@@ -568,16 +568,12 @@ def build_published_spls(workspace: str, lines: list[dict]) -> list[dict]:
 def assemble_index(features: list[dict], spls: list[dict], sources: dict) -> dict:
     compute_used_by(features)
     features = sorted(features, key=lambda e: e["short"])
-    try:
-        import importlib.metadata
+    from splent_cli.utils.running_version import cli_version
 
-        cli_version = importlib.metadata.version("splent_cli")
-    except Exception:
-        cli_version = "unknown"
     return {
         "schema": INDEX_SCHEMA,
         "generated_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
-        "generator": f"splent_cli/{cli_version}",
+        "generator": f"splent_cli/{cli_version()}",
         "sources": sources,
         "features": features,
         "spls": spls,

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/services/release.py

@@ -302,17 +302,61 @@ def _git_out(cwd: str, args: list[str]) -> str | None:
     return r.stdout.strip() if r.returncode == 0 else None
 
 
+_RELEASE_BRANCHES: dict[str, str] = {}
+
+
+def release_branch(cwd: str) -> str:
+    """The branch a release pushes to: the one origin calls its default.
+
+    A repository whose default branch is master would otherwise get a second
+    branch called main that no clone checks out, and a server pulling master
+    would never see the release. Origin's HEAD as this clone recorded it,
+    else as origin reports it, else the branch checked out here, else main.
+    """
+    key = os.path.realpath(cwd)
+    if key in _RELEASE_BRANCHES:
+        return _RELEASE_BRANCHES[key]
+    branch = None
+    ref = _git_out(
+        cwd, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]
+    )
+    if ref and ref.startswith("origin/"):
+        branch = ref[len("origin/") :]
+    if not branch:
+        try:
+            r = subprocess.run(
+                ["git", "ls-remote", "--symref", "origin", "HEAD"],
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                env=_non_interactive_env(),
+                timeout=GIT_NETWORK_TIMEOUT,
+            )
+            out = r.stdout if isinstance(r.stdout, str) else ""
+            m = re.search(r"^ref: refs/heads/(\S+)\s+HEAD", out, re.M)
+            branch = m.group(1) if m else None
+        except subprocess.TimeoutExpired:
+            branch = None
+    if not branch:
+        current = _git_out(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
+        if current and current != "HEAD":
+            branch = current
+    _RELEASE_BRANCHES[key] = branch or "main"
+    return _RELEASE_BRANCHES[key]
+
+
 def push_main(cwd: str) -> None:
-    """Push HEAD to origin/main and verify that origin/main really carries it.
+    """Push HEAD to the release branch and verify that origin really carries it.
 
     Pushing is not the same as having pushed. A tag whose commit is on no remote
     branch shows up on the git host as a release of source nobody can find, and
     that is what happens when a clean working tree is read as "nothing to do".
     """
     env = _non_interactive_env()
+    branch = release_branch(cwd)
     try:
         subprocess.run(
-            ["git", "push", "origin", "HEAD:main"],
+            ["git", "push", "origin", f"HEAD:{branch}"],
             cwd=cwd,
             check=True,
             capture_output=True,
@@ -322,11 +366,11 @@ def push_main(cwd: str) -> None:
         )
     except subprocess.CalledProcessError as e:
         stderr = e.stderr.strip() if e.stderr else str(e)
-        click.secho(f"  error: could not push to origin/main: {stderr}", fg="red")
+        click.secho(f"  error: could not push to origin/{branch}: {stderr}", fg="red")
         raise SystemExit(1)
     except subprocess.TimeoutExpired:
         click.secho(
-            "  error: the push to origin/main did not finish within "
+            f"  error: the push to origin/{branch} did not finish within "
             f"{GIT_NETWORK_TIMEOUT // 60} minutes.",
             fg="red",
         )
@@ -335,7 +379,7 @@ def push_main(cwd: str) -> None:
     head = _git_out(cwd, ["rev-parse", "HEAD"])
     try:
         subprocess.run(
-            ["git", "fetch", "origin", "main"],
+            ["git", "fetch", "origin", branch],
             cwd=cwd,
             capture_output=True,
             text=True,
@@ -343,21 +387,21 @@ def push_main(cwd: str) -> None:
             timeout=GIT_NETWORK_TIMEOUT,
         )
     except subprocess.TimeoutExpired:
-        # The push itself moved origin/main in this clone, which is what the
+        # The push itself moved the remote branch in this clone, which is what the
         # check below reads.
         pass
-    remote = _git_out(cwd, ["rev-parse", "origin/main"])
+    remote = _git_out(cwd, ["rev-parse", f"origin/{branch}"])
     if head and remote and head != remote:
         # Not necessarily wrong (someone else may have pushed on top), but the
         # tag must describe a commit the remote branch contains.
         contains = subprocess.run(
-            ["git", "merge-base", "--is-ancestor", head, "origin/main"],
+            ["git", "merge-base", "--is-ancestor", head, f"origin/{branch}"],
             cwd=cwd,
             capture_output=True,
         )
         if contains.returncode != 0:
             click.secho(
-                "  error: origin/main does not contain the commit being released.",
+                f"  error: origin/{branch} does not contain the commit being released.",
                 fg="red",
             )
             click.secho(
@@ -366,7 +410,7 @@ def push_main(cwd: str) -> None:
                 fg="yellow",
             )
             raise SystemExit(1)
-    click.echo("  push     origin/main updated")
+    click.echo(f"  push     origin/{branch} updated")
 
 
 def git_is_clean(cwd: str) -> bool:
@@ -420,7 +464,7 @@ def read_project_version(pyproject_path: str) -> str | None:
 
 
 def sync_main_if_needed(cwd: str) -> None:
-    """Make sure origin/main carries the commit that is about to be tagged.
+    """Make sure the release branch on origin carries the commit about to be tagged.
 
     A resume can run on a repository where the release commit was made and
     never pushed, which is exactly the state a failed upload leaves behind.
@@ -429,9 +473,10 @@ def sync_main_if_needed(cwd: str) -> None:
     left alone, because a recovery command must not resolve a divergence in
     someone's branch on its own.
     """
+    branch = release_branch(cwd)
     try:
         subprocess.run(
-            ["git", "fetch", "origin", "main"],
+            ["git", "fetch", "origin", branch],
             cwd=cwd,
             capture_output=True,
             text=True,
@@ -441,7 +486,7 @@ def sync_main_if_needed(cwd: str) -> None:
     except subprocess.TimeoutExpired:
         pass
     head = _git_out(cwd, ["rev-parse", "HEAD"])
-    remote = _git_out(cwd, ["rev-parse", "origin/main"])
+    remote = _git_out(cwd, ["rev-parse", f"origin/{branch}"])
     if not head or not remote or head == remote:
         return
 
@@ -455,13 +500,13 @@ def sync_main_if_needed(cwd: str) -> None:
             == 0
         )
 
-    if _is_ancestor(head, "origin/main"):
+    if _is_ancestor(head, f"origin/{branch}"):
         return
     if _is_ancestor(remote, "HEAD"):
         push_main(cwd)
         return
     click.secho(
-        "  warn: origin/main and this checkout have diverged, so the commit "
+        f"  warn: origin/{branch} and this checkout have diverged, so the commit "
         "being tagged was not pushed. Reconcile the branch yourself.",
         fg="yellow",
     )
@@ -1698,7 +1743,7 @@ def run_release_pipeline(
     try:
         if to_forge:
             push_main(path)
-            accepted.append("origin/main")
+            accepted.append(f"origin/{release_branch(path)}")
             create_and_push_tag(path, tag)
             accepted.append(f"the {tag} tag on the forge")
             failure = create_github_release(

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/templates/product/product_ci_upgrade.yml.j2

@@ -60,15 +60,21 @@ jobs:
           git add pyproject.toml
           git commit -m "Upgrade the pinned features"
           git push --force "https://x-access-token:${FORGE_TOKEN}@{{ forge_host }}/${GITHUB_REPOSITORY}.git" "$BRANCH"
+          # The pull request goes to the branch the repository calls its default.
+          export BASE=$(curl --silent -H "Authorization: token ${FORGE_TOKEN}" \
+            "https://{{ forge_host }}/api/v1/repos/${GITHUB_REPOSITORY}" \
+            | python3 -c 'import json, sys; print(json.load(sys.stdin).get("default_branch") or "main")' \
+            || echo main)
           python3 - <<'PY' > pr.json
           import json
+          import os
           log = open("../upgrade.log", encoding="utf-8", errors="replace").read()
           body = (
               "The pinned features have newer releases that install together and "
               "keep the product valid in its line. Review the plan below, merge, "
               "and publish with splent product:release.\n\n```\n" + log[-60000:] + "\n```\n"
           )
-          print(json.dumps({"head": "splent/feature-upgrades", "base": "main",
+          print(json.dumps({"head": "splent/feature-upgrades", "base": os.environ.get("BASE") or "main",
                             "title": "Upgrade the pinned features", "body": body}))
           PY
           curl --silent --show-error --fail -X POST \

splent_cli-1.34.1/src/splent_cli/utils/running_version.py

@@ -0,0 +1,28 @@
+"""The version of the CLI that is running.
+
+An editable install records its version once, when it is installed, and the
+checkout moves on with every release. So when the CLI runs from a checkout,
+the checkout's pyproject.toml is the version; an installed wheel answers
+through its metadata.
+"""
+
+import tomllib
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+
+def cli_version() -> str:
+    import splent_cli
+
+    pyproject = Path(splent_cli.__file__).resolve().parents[2] / "pyproject.toml"
+    if pyproject.is_file():
+        try:
+            project = tomllib.loads(pyproject.read_text()).get("project", {})
+        except (OSError, tomllib.TOMLDecodeError):
+            project = {}
+        if project.get("name") == "splent_cli" and project.get("version"):
+            return str(project["version"])
+    try:
+        return version("splent_cli")
+    except PackageNotFoundError:
+        return "dev"

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/utils/template_drift.py

@@ -10,12 +10,9 @@ from pathlib import Path
 
 from jinja2 import Environment, FileSystemLoader, select_autoescape
 
-try:
-    from importlib.metadata import version as _pkg_version
+from splent_cli.utils.running_version import cli_version
 
-    CLI_VERSION = _pkg_version("splent_cli")
-except Exception:
-    CLI_VERSION = "dev"
+CLI_VERSION = cli_version()
 
 
 # ── Jinja helpers ─────────────────────────────────────────────────────────────

{splent_cli-1.34.0 → splent_cli-1.34.1}/src/splent_cli/utils/upgrade_plan.py

@@ -399,6 +399,9 @@ def resolve_with_pip(
             "install",
             "--dry-run",
             "--ignore-installed",
+            # pip's HTTP cache keeps PyPI's index for minutes, so a version
+            # released moments ago would be missing from the plan.
+            "--no-cache-dir",
             "--quiet",
             "--disable-pip-version-check",
             "--no-input",

{splent_cli-1.34.0 → splent_cli-1.34.1/src/splent_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.34.0
+Version: 1.34.1
 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.34.0 → splent_cli-1.34.1}/src/splent_cli.egg-info/SOURCES.txt

@@ -273,6 +273,7 @@ src/splent_cli/utils/path_utils.py
 src/splent_cli/utils/proc.py
 src/splent_cli/utils/redact.py
 src/splent_cli/utils/refinement_facts.py
+src/splent_cli/utils/running_version.py
 src/splent_cli/utils/template_drift.py
 src/splent_cli/utils/toml_edit.py
 src/splent_cli/utils/upgrade_plan.py