splent-cli 1.29.0__tar.gz → 1.30.0__tar.gz

{splent_cli-1.29.0/src/splent_cli.egg-info → splent_cli-1.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.29.0
+Version: 1.30.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

{splent_cli-1.29.0 → splent_cli-1.30.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.29.0"
+version = "1.30.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.29.0 → splent_cli-1.30.0}/src/splent_cli/commands/feature/feature_release.py

@@ -3,6 +3,7 @@ feature:release — Release a feature: bump version, tag, publish to the git for
 """
 
 import ast
+import json
 import os
 import re
 import shutil
@@ -363,6 +364,83 @@ def _extract_commands(commands_path: Path) -> list[str]:
     return sorted(set(re.findall(r"""@click\.command\s*\(\s*['"]([^'"]+)['"]""", text)))
 
 
+def _call_name(node) -> str:
+    """``click.command`` for the decorator call ``@click.command(...)``."""
+    func = node.func if isinstance(node, ast.Call) else node
+    parts = []
+    while isinstance(func, ast.Attribute):
+        parts.append(func.attr)
+        func = func.value
+    if isinstance(func, ast.Name):
+        parts.append(func.id)
+    return ".".join(reversed(parts))
+
+
+def _literal(node):
+    try:
+        return ast.literal_eval(node)
+    except (ValueError, SyntaxError, TypeError):
+        return None
+
+
+def _first_line(text) -> str:
+    for line in (text or "").strip().splitlines():
+        if line.strip():
+            return line.strip()
+    return ""
+
+
+def _extract_command_help(commands_path: Path) -> dict:
+    """What each command a feature adds is for, and how it is called.
+
+    ``{name: {"usage": "EMAIL ROLE [OPTIONS]", "help": "..."}}``, read from
+    the source without importing it: the arguments in the order they are
+    declared, in click's uppercase, ``[OPTIONS]`` when there are any, and the
+    first line of ``short_help``, ``help`` or the docstring. The marketplace
+    shows it next to each command, which used to be a bare name.
+    """
+    if not commands_path.exists():
+        return {}
+    try:
+        tree = ast.parse(commands_path.read_text())
+    except SyntaxError:
+        return {}
+    found = {}
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        name, help_text, usage, has_options = None, "", [], False
+        for deco in node.decorator_list:
+            if not isinstance(deco, ast.Call):
+                continue
+            kind = _call_name(deco)
+            if kind.endswith("command") and deco.args:
+                name = _literal(deco.args[0])
+                kwargs = {k.arg: _literal(k.value) for k in deco.keywords}
+                help_text = kwargs.get("short_help") or kwargs.get("help") or ""
+            elif kind.endswith("argument") and deco.args:
+                arg = _literal(deco.args[0])
+                if not isinstance(arg, str):
+                    continue
+                kwargs = {k.arg: _literal(k.value) for k in deco.keywords}
+                metavar = arg.upper().replace("-", "_")
+                if kwargs.get("nargs") == -1:
+                    metavar += "..."
+                optional = kwargs.get("required") is False or "default" in kwargs
+                usage.append(f"[{metavar}]" if optional else metavar)
+            elif kind.endswith("option"):
+                has_options = True
+        if not isinstance(name, str):
+            continue
+        if has_options:
+            usage.append("[OPTIONS]")
+        found[name] = {
+            "usage": " ".join(usage),
+            "help": _first_line(help_text) or _first_line(ast.get_docstring(node)),
+        }
+    return dict(sorted(found.items()))
+
+
 def _feature_sources(src_dir: Path):
     """The feature's own Python files, without its tests.
 
@@ -693,6 +771,7 @@ def infer_contract(
     templates = _extract_templates(src_dir)
     template_hook_slots = _extract_template_hook_slots(src_dir)
     commands = _extract_commands(src_dir / "commands.py")
+    commands_help = _extract_command_help(src_dir / "commands.py")
     docker = _extract_docker(feature_root)
     docker_contract = _extract_docker_contract(feature_root)
     req_features, env_vars = _scan_dependencies(src_dir, feature_name)
@@ -751,6 +830,7 @@ def infer_contract(
         "blueprints": blueprints,
         "models": models,
         "commands": commands,
+        "commands_help": commands_help,
         "hooks": hooks,
         "services": services,
         "signals": signals_provided,
@@ -945,7 +1025,8 @@ def write_contract(pyproject_path: str, contract: dict, feature_name: str) -> No
         f"signals    = {_toml_value(contract.get('signals', []))}\n"
         f"translations = {_toml_value(contract.get('translations', []))}\n"
         f"docker     = {_toml_value(contract['docker'])}\n"
-        "\n"
+        + _commands_help_block(contract.get("commands_help") or {})
+        + "\n"
         "[tool.splent.contract.requires]\n"
         f"features = {_toml_value(contract['requires_features'])}\n"
         + (
@@ -989,6 +1070,20 @@ def write_contract(pyproject_path: str, contract: dict, feature_name: str) -> No
     path.write_text(text + contract_block + refinement_block)
 
 
+def _commands_help_block(commands_help: dict) -> str:
+    """The ``[tool.splent.contract.provides.commands_help]`` table, or nothing."""
+    if not commands_help:
+        return ""
+    lines = ["\n[tool.splent.contract.provides.commands_help]\n"]
+    for name, entry in commands_help.items():
+        key = name if re.fullmatch(r"[A-Za-z0-9_-]+", name) else json.dumps(name)
+        lines.append(
+            f"{key} = {{ usage = {json.dumps(entry.get('usage', ''))}, "
+            f"help = {json.dumps(entry.get('help', ''))} }}\n"
+        )
+    return "".join(lines)
+
+
 # ── Compile assets ────────────────────────────────────────────────────
 
 

{splent_cli-1.29.0 → splent_cli-1.30.0}/src/splent_cli/commands/product/product_release.py

@@ -2,8 +2,11 @@
 product:release, a product release: version bump, tag, forge, PyPI and the image.
 """
 
+import contextlib
+import json
 import os
 import subprocess
+import tempfile
 
 import click
 from splent_cli.commands.product.product_build import (
@@ -63,7 +66,32 @@ def release_targets(product: str, version: str, product_path: str, org: str):
     return image_registry.image_targets(product, version, org, registries, mirrors)
 
 
-def _login(target) -> bool:
+#: Docker Hub answers to these names in a client's configuration.
+_DOCKER_HUB_HOSTS = ("index.docker.io", "registry-1.docker.io", "docker.io")
+
+
+@contextlib.contextmanager
+def registry_session(hosts=()):
+    """A docker client configuration of its own for one release's logins and pushes.
+
+    The host's configuration may hand credentials to a helper, the macOS
+    keychain under Docker Desktop, and that helper refuses to store a login
+    for a host the keychain already holds a git password for ("The specified
+    item already exists in the keychain"), which stopped the marketplace's
+    first release. A configuration of its own also keeps the release tokens
+    off the machine: it is deleted when the release is done.
+    """
+    # An empty credsStore is not enough: the docker client then detects the
+    # platform's helper again. An empty helper per host is what makes it keep
+    # the login in this file.
+    helpers = {host: "" for host in (*hosts, *_DOCKER_HUB_HOSTS) if host}
+    with tempfile.TemporaryDirectory(prefix="splent-docker-") as config_dir:
+        with open(os.path.join(config_dir, "config.json"), "w") as handle:
+            json.dump({"auths": {}, "credHelpers": helpers}, handle)
+        yield {**os.environ, "DOCKER_CONFIG": config_dir}
+
+
+def _login(target, env=None) -> bool:
     user, secret = target.credentials()
     if not user or not secret:
         return False
@@ -71,7 +99,7 @@ def _login(target) -> bool:
     if target.host:
         command.insert(2, target.host)
     try:
-        run(command, input=secret, capture=True)
+        run(command, input=secret, capture=True, env=env)
     except subprocess.CalledProcessError:
         return False
     return True
@@ -105,51 +133,52 @@ def release_docker_image(product: str, version: str, docker_dir: str, targets):
         )
         raise SystemExit(1)
 
-    usable = []
-    for target in targets:
-        click.echo(f"  docker   logging into {target.label}...")
-        if _login(target):
-            usable.append(target)
-            continue
-        if target.mirror:
-            click.secho(
-                f"  docker   the {target.label} mirror is left out, its login failed "
-                f"or {' / '.join(target.credential_names())} are not set",
-                fg="yellow",
-            )
-            continue
-        user_env, secret_env = target.credential_names()
-        click.secho(
-            f"  error: could not log into {target.label}. Check {user_env} and "
-            f"{secret_env}.",
-            fg="red",
-        )
-        raise SystemExit(1)
-
-    refs = [ref for target in usable for ref in target.refs]
-    click.echo("  docker   building image...")
-    try:
-        build_production_image(product, str(context.workspace()), docker_dir, refs)
-    except subprocess.CalledProcessError:
-        click.secho("  error: Docker image build failed.", fg="red")
-        raise SystemExit(1)
-
-    for target in usable:
-        click.echo(f"  docker   pushing to {target.label}...")
-        try:
-            for ref in target.refs:
-                run(["docker", "push", ref])
-        except subprocess.CalledProcessError:
+    with registry_session([t.host for t in targets]) as docker_env:
+        usable = []
+        for target in targets:
+            click.echo(f"  docker   logging into {target.label}...")
+            if _login(target, docker_env):
+                usable.append(target)
+                continue
             if target.mirror:
                 click.secho(
-                    f"  docker   the push to the {target.label} mirror failed and is "
-                    "left out",
+                    f"  docker   the {target.label} mirror is left out, its login "
+                    f"failed or {' / '.join(target.credential_names())} are not set",
                     fg="yellow",
                 )
                 continue
-            click.secho(f"  error: the push to {target.label} failed.", fg="red")
+            user_env, secret_env = target.credential_names()
+            click.secho(
+                f"  error: could not log into {target.label}. Check {user_env} and "
+                f"{secret_env}.",
+                fg="red",
+            )
+            raise SystemExit(1)
+
+        refs = [ref for target in usable for ref in target.refs]
+        click.echo("  docker   building image...")
+        try:
+            build_production_image(product, str(context.workspace()), docker_dir, refs)
+        except subprocess.CalledProcessError:
+            click.secho("  error: Docker image build failed.", fg="red")
             raise SystemExit(1)
-        click.echo(f"  docker   {', '.join(target.refs)}")
+
+        for target in usable:
+            click.echo(f"  docker   pushing to {target.label}...")
+            try:
+                for ref in target.refs:
+                    run(["docker", "push", ref], env=docker_env)
+            except subprocess.CalledProcessError:
+                if target.mirror:
+                    click.secho(
+                        f"  docker   the push to the {target.label} mirror failed "
+                        "and is left out",
+                        fg="yellow",
+                    )
+                    continue
+                click.secho(f"  error: the push to {target.label} failed.", fg="red")
+                raise SystemExit(1)
+            click.echo(f"  docker   {', '.join(target.refs)}")
 
     click.echo("  docker   push complete")
 

{splent_cli-1.29.0 → splent_cli-1.30.0}/src/splent_cli/commands/spl/spl_publish.py

@@ -21,6 +21,7 @@ saying what came back.
 
 import os
 import re
+import time
 import tomllib
 
 import click
@@ -225,6 +226,119 @@ def _concept_doi(result: dict) -> str:
     return ""
 
 
+# ---------------------------------------------------------------------------
+# Waiting for the DOI
+# ---------------------------------------------------------------------------
+
+#: Seconds between two questions about a release that is still being minted.
+POLL_INTERVAL = 5
+#: How long to keep asking about a release that is still being minted. Longer
+#: than the marketplace waits on a mint before it goes looking for the DOI.
+WAIT_LIMIT = 20 * 60
+#: How long to keep asking once the marketplace says it lost track of the
+#: mint. It looks for the DOI about once a minute, so this is a few looks.
+UNKNOWN_GRACE = 5 * 60
+#: How often to say it is still going, so a quiet terminal does not read as
+#: a hung one.
+PROGRESS_EVERY = 30
+
+#: Error codes that waiting longer cannot fix.
+_FINAL_CODES = frozenset(
+    {
+        marketplace_api.CODE_FORBIDDEN,
+        marketplace_api.CODE_NOT_FOUND,
+        marketplace_api.CODE_INVALID_REQUEST,
+    }
+)
+
+# Swapped out by the tests, so nothing there really waits.
+_sleep = time.sleep
+_clock = time.monotonic
+
+
+def _duration(seconds: float) -> str:
+    minutes, rest = divmod(int(seconds), 60)
+    return f"{minutes}m {rest:02d}s" if minutes else f"{rest}s"
+
+
+def _wait_for_release(client, spl_name: str, accepted: dict) -> dict:
+    """Ask about an accepted release until the marketplace settles it.
+
+    Returns the last answer: published or failed, or still reserved or
+    unknown once the limits above run out. Nothing is written down until it
+    says published, so stopping early, by limit or by Ctrl+C, loses nothing.
+    """
+    version = accepted.get("version")
+    if not version:
+        raise marketplace_api.MarketplaceError(
+            "The marketplace accepted the release but did not say which version it is.",
+            status=None,
+            code=marketplace_api.CODE_BAD_RESPONSE,
+        )
+    click.echo(
+        f"  Release {version} accepted. Minting its DOI, which usually takes a "
+        "minute or two."
+    )
+
+    started = last_report = _clock()
+    unknown_since = None
+    status = accepted
+    warned = False
+    while True:
+        state = str(status.get("state") or "")
+        if state not in ("reserved", "unknown"):
+            return status
+        now = _clock()
+        if state == "unknown" and unknown_since is None:
+            unknown_since = now
+        if now - started >= WAIT_LIMIT or (
+            unknown_since is not None and now - unknown_since >= UNKNOWN_GRACE
+        ):
+            return status
+        if now - last_report >= PROGRESS_EVERY:
+            click.echo(f"  Still minting ({_duration(now - started)}).")
+            last_report = now
+        _sleep(POLL_INTERVAL)
+        try:
+            status = client.release_status(spl_name, version)
+        except marketplace_api.MarketplaceError as e:
+            if e.dead_token or e.code in _FINAL_CODES:
+                raise
+            # A blip between two questions says nothing about the release,
+            # which carries on in the marketplace either way.
+            if not warned:
+                click.secho(
+                    f"  The marketplace did not answer ({e.reason or e}). "
+                    "Asking again.",
+                    fg="yellow",
+                )
+                warned = True
+
+
+def _come_back_later(spl_name: str, version, state: str) -> None:
+    """What to do about a release that has not settled yet. Always exits."""
+    click.echo()
+    if state == "unknown":
+        click.secho(
+            f"  Release {version} did not report back, so the marketplace is "
+            "looking for its DOI.",
+            fg="yellow",
+        )
+    else:
+        click.secho(
+            f"  Release {version} is still being minted. The marketplace carries "
+            "on with it.",
+            fg="yellow",
+        )
+    click.echo(
+        f"     Run splent spl:publish {spl_name} again later. The same model is "
+        "answered with its DOI once it exists, and is never minted twice."
+    )
+    click.echo("     Nothing was written down locally yet.")
+    click.echo()
+    raise SystemExit(1)
+
+
 # ---------------------------------------------------------------------------
 # Command
 # ---------------------------------------------------------------------------
@@ -315,6 +429,7 @@ def spl_publish(spl_name, registry_option, dry_run):
         click.echo()
         click.echo("  Would POST the model to /api/v1/spls/<name>/releases and:")
         click.echo("    - let the marketplace publish or version it on its own key")
+        click.echo("    - wait while it mints the DOI")
         click.echo("    - let it verify the published file byte for byte")
         click.echo("    - record the DOI it reports")
         if metadata_path:
@@ -360,6 +475,36 @@ def spl_publish(spl_name, registry_option, dry_run):
         click.echo()
         raise SystemExit(1)
 
+    if result.get("accepted"):
+        try:
+            result = _wait_for_release(client, spl_name, result)
+        except marketplace_api.MarketplaceError as e:
+            handle_error(e, url=target.url, forget=not cred.from_environment)
+            click.echo()
+            raise SystemExit(1)
+        except KeyboardInterrupt:
+            click.echo()
+            click.secho("  Stopped waiting.", fg="yellow")
+            click.echo(
+                f"     The marketplace carries on with release {result.get('version')}. "
+                f"Run splent spl:publish {spl_name} again to pick up its DOI."
+            )
+            raise SystemExit(130)
+        state = str(result.get("state") or "")
+        if state == "failed":
+            click.secho(
+                f"  Release {result.get('version')} was refused. Nothing was minted.",
+                fg="red",
+            )
+            detail = str(result.get("detail") or "").strip()
+            if detail:
+                click.echo(f"     {detail}")
+            click.echo("     Fix the model and publish it again.")
+            click.echo()
+            raise SystemExit(1)
+        if state != "published":
+            _come_back_later(spl_name, result.get("version"), state)
+
     doi, remote_file = _pointer(result)
     concept_doi = _concept_doi(result)
     if not doi:

{splent_cli-1.29.0 → splent_cli-1.30.0}/src/splent_cli/services/marketplace.py

@@ -19,7 +19,8 @@ Layout of the index document (schema 1)::
     }
 
 Feature entries carry the full contract (provides / requires / extensible /
-docker), the derived archetype, presentation metadata (description,
+docker), the settings the feature declares under ``[tool.splent.config]``
+(``config``), the derived archetype, presentation metadata (description,
 category, tags), distribution state (latest tag, PyPI presence) and the
 computed reverse dependencies (``used_by``).
 """
@@ -36,6 +37,11 @@ import click
 INDEX_SCHEMA = 1
 FEATURE_PREFIX = "splent_feature_"
 
+# Where a feature declares the variables it reads, and the value a setting
+# holds when only the deployment can supply it (a secret).
+CONFIG_TABLE = ("tool", "splent", "config")
+REQUIRED_VALUE = "<SET>"
+
 # Feeds feature:search / feature:info when no explicit path is given.
 INDEX_URL_ENV = "SPLENT_INDEX_URL"
 
@@ -72,6 +78,67 @@ def index_cache_path(workspace: str) -> Path:
 # ── Feature entries ───────────────────────────────────────────────────
 
 
+# The value types product:env writes into an env file. A table or a date
+# under [tool.splent.config] never reaches the environment, so it is no
+# setting a product can change.
+_CONFIG_TYPES = (bool, int, float, str, list)
+
+
+def _config_text(value) -> str:
+    """A declared value as the environment receives it from ``product:env``.
+
+    Booleans are ``true``/``false``, numbers and strings their plain text, and
+    a list its items joined by commas.
+    """
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, list):
+        return ",".join(_config_text(item) for item in value)
+    return str(value)
+
+
+def config_declarations(pyproject_text: str, data: dict | None = None) -> list[dict]:
+    """The settings a feature declares under ``[tool.splent.config]``.
+
+    One ``{"key", "default", "required", "help"}`` per key, in the order they
+    are declared (tomllib keeps it), for every key whose value reaches the
+    environment. ``default`` is the value as text (see :func:`_config_text`).
+    A value of ``<SET>`` means only the deployment can supply it, so it gives
+    ``required`` true and an empty ``default``. ``help`` is the comment above
+    the key, or trailing its value (see :func:`toml_edit.key_comments`), and
+    ``""`` when there is none.
+
+    The values come from tomllib (*data*, parsed from *pyproject_text* when
+    not given) and only the comments from the text, so an unusual layout
+    costs the help and never a key or a value.
+    """
+    from splent_cli.utils.toml_edit import TomlEditError, key_comments
+
+    if data is None:
+        data = tomllib.loads(pyproject_text)
+    declared = data.get("tool", {}).get("splent", {}).get("config", {})
+    if not isinstance(declared, dict) or not declared:
+        return []
+    try:
+        comments = key_comments(pyproject_text, CONFIG_TABLE)
+    except TomlEditError:
+        comments = {}
+    settings = []
+    for key, value in declared.items():
+        if not isinstance(value, _CONFIG_TYPES):
+            continue
+        required = isinstance(value, str) and value.strip() == REQUIRED_VALUE
+        settings.append(
+            {
+                "key": key,
+                "default": "" if required else _config_text(value),
+                "required": required,
+                "help": comments.get(key, ""),
+            }
+        )
+    return settings
+
+
 def feature_entry_from_pyproject(
     pyproject_text: str,
     *,
@@ -109,6 +176,7 @@ def feature_entry_from_pyproject(
         "provides": contract.get("provides", {}),
         "requires": contract.get("requires", {}),
         "extensible": contract.get("extensible", {}),
+        "config": config_declarations(pyproject_text, data),
         "docker": contract.get("docker") or None,
         "refinement": splent.get("refinement") or None,
         "cli_version": splent.get("cli_version"),

{splent_cli-1.29.0 → splent_cli-1.30.0}/src/splent_cli/services/marketplace_api.py

@@ -17,6 +17,10 @@ extra fields and loud about missing ones)::
     GET    /api/v1/spls                 public
     GET    /api/v1/spls/<name>          public -> {name, description, uvl{...}}
     POST   /api/v1/spls/<name>/releases Bearer, multipart with the uvl file
+                                        Prefer: respond-async -> 202 {accepted,
+                                        version, state} while the DOI is minted
+    GET    /api/v1/spls/<name>/releases/<version>
+                                        Bearer -> {state, doi, uvl{...}, ...}
 
 Nothing here prints, and nothing here ever puts a token in a message: an error
 string from this module is safe to show to the user verbatim.
@@ -36,6 +40,11 @@ USER_AGENT = "splent-cli"
 DEFAULT_TIMEOUT = 15
 UPLOAD_TIMEOUT = 60
 
+#: RFC 7240. Asks the marketplace to answer a release as soon as it is
+#: reserved and mint the DOI in the background. A marketplace that predates
+#: it ignores the header and answers when the DOI exists, as it always did.
+PREFER_ASYNC = "respond-async"
+
 #: Lifetime requested for a token created by ``splent login``.
 DEFAULT_TTL_DAYS = 90
 
@@ -451,6 +460,7 @@ class MarketplaceClient:
         timeout: int | None = None,
         unauthenticated_code: str | None = None,
         sent_but_unanswered: str | None = None,
+        extra_headers: dict | None = None,
     ):
         """Perform the request. Returns parsed JSON, or None for an empty body.
 
@@ -465,7 +475,7 @@ class MarketplaceClient:
             response = requests.request(
                 method,
                 url,
-                headers=self._headers(auth=auth),
+                headers={**self._headers(auth=auth), **(extra_headers or {})},
                 json=json_body,
                 files=files,
                 data=data,
@@ -637,6 +647,10 @@ class MarketplaceClient:
         spends anything: on the far side the marketplace relays it to UVLHub
         with its own key and a DOI may be minted. ``splent spl:publish`` is its
         only caller and there is meant to be exactly one.
+
+        It asks for the answer as soon as the release is reserved. A body with
+        ``accepted`` set means the DOI is still being minted, and
+        :meth:`release_status` says how it ends.
         """
         files = {
             UVL_FIELD_NAME: (filename, uvl_bytes, "text/plain"),
@@ -651,10 +665,24 @@ class MarketplaceClient:
             sent_but_unanswered=(
                 f"The upload of {name} was sent to the marketplace at {self.base_url} "
                 f"but no answer came back within {UPLOAD_TIMEOUT} seconds. The "
-                "release may have completed, so check the product line page on "
-                "the marketplace before publishing again."
+                "release may have completed. Publishing the same model again is "
+                "safe. The marketplace answers it with the DOI it minted and "
+                "never mints a second one."
             ),
+            extra_headers={"Prefer": PREFER_ASYNC},
         )
         if payload is None:
             return {}
         return self._expect_dict(payload, "release response")
+
+    def release_status(self, name: str, version) -> dict:
+        """How one release of *name* stands: reserved, published, failed or unknown.
+
+        The path is built here from the name and the version, never taken from
+        the server's ``status_url``: the token goes with this request, and it
+        only ever goes to the marketplace it was issued by.
+        """
+        payload = self._request(
+            "GET", f"/api/v1/spls/{name}/releases/{int(version)}", auth=True
+        )
+        return self._expect_dict(payload, "release status")