datex-studio-cli 0.4.3__tar.gz → 0.4.5__tar.gz

{datex_studio_cli-0.4.3 → datex_studio_cli-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datex-studio-cli
-Version: 0.4.3
+Version: 0.4.5
 Summary: CLI for Datex Studio low-code platform, designed for LLM-based AI agents
 Project-URL: Homepage, https://github.com/datex/datex-studio-cli
 Project-URL: Documentation, https://github.com/datex/datex-studio-cli

{datex_studio_cli-0.4.3 → datex_studio_cli-0.4.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datex-studio-cli"
-version = "0.4.3"
+version = "0.4.5"
 description = "CLI for Datex Studio low-code platform, designed for LLM-based AI agents"
 readme = "README.md"
 license = "MIT"

{datex_studio_cli-0.4.3 → datex_studio_cli-0.4.5}/src/dxs/__init__.py

@@ -1,4 +1,4 @@
 """Datex Studio CLI - Command-line interface for Datex Studio platform."""
 
-__version__ = "0.4.3"
+__version__ = "0.4.5"
 __app_name__ = "dxs"

{datex_studio_cli-0.4.3 → datex_studio_cli-0.4.5}/src/dxs/cli.py

@@ -507,18 +507,20 @@ def _ctx_extras(dxs_ctx: "DxsContext | None") -> dict[str, Any]:
 
 
 @cli.command("update")
-@click.option(
-    "--check",
-    "check_only",
-    is_flag=True,
-    default=False,
-    help="Print whether an update is available without prompting to install",
-)
-def update_cmd(check_only: bool) -> None:
-    """Check PyPI for a newer release and optionally upgrade in place."""
+def update_cmd() -> None:
+    """Check PyPI for a newer release and print the upgrade command.
+
+    This command never performs the upgrade itself — run the printed
+    command in a fresh shell. This avoids the running-binary file-lock
+    issues that any in-process upgrade hits on Windows.
+    """
+    import time
+
     from dxs.utils.update_check import (
+        PACKAGE_NAME,
         _fetch_latest_version,
-        _run_upgrade,
+        _read_cache,
+        _write_cache,
         detect_upgrade_command,
         is_newer,
     )
@@ -536,12 +538,19 @@ def update_cmd(check_only: bool) -> None:
         return
 
     upgrade_cmd = detect_upgrade_command()
-    click.echo(f"Upgrade command: {upgrade_cmd}", err=True)
-    if check_only:
-        return
-
-    if click.confirm("Upgrade now?", default=True, err=True):
-        sys.exit(_run_upgrade(upgrade_cmd))
+    click.echo("", err=True)
+    click.echo(f"  A new release of dxs is available: {__version__} → {latest}", err=True)
+    click.echo(f"  To upgrade, run: {upgrade_cmd}", err=True)
+    click.echo(f"  https://pypi.org/project/{PACKAGE_NAME}/{latest}/", err=True)
+
+    # Refresh the cache and suppress the auto-banner for the next dedupe
+    # window — the user has explicitly seen the news.
+    now = time.time()
+    cache = _read_cache() or {}
+    cache["latest"] = latest
+    cache["checked_at"] = now
+    cache["last_notified_at"] = now
+    _write_cache(cache)
 
 
 # Register commands when module loads

{datex_studio_cli-0.4.3 → datex_studio_cli-0.4.5}/src/dxs/utils/update_check.py

@@ -1,9 +1,13 @@
-"""PyPI update check.
+"""PyPI update notifier.
 
-On each invocation, reads a cached "latest version on PyPI" entry. If a newer
-version is available and we're attached to an interactive terminal, prints a
-banner and offers to upgrade in place. The PyPI fetch happens in a background
-daemon thread so the user's command is never delayed.
+After each command, if the on-disk cache says a newer version exists on
+PyPI, print a one-time banner to stderr telling the user how to upgrade.
+The actual upgrade is the user's responsibility — we never exec, spawn,
+or otherwise touch the running install. This sidesteps every file-lock,
+process-replacement, and platform-specific upgrade problem.
+
+The PyPI fetch happens in a background daemon thread, so a stale cache is
+refreshed for *next* time. The current run never blocks on the network.
 
 Environment / flag controls:
 - ``DXS_NO_UPDATE_CHECK=1`` disables both the check and the banner.
@@ -16,7 +20,6 @@ from __future__ import annotations
 import json
 import os
 import re
-import shlex
 import sys
 import threading
 import time
@@ -31,7 +34,7 @@ from dxs.utils.paths import get_datex_home
 PYPI_URL = "https://pypi.org/pypi/datex-studio-cli/json"
 PACKAGE_NAME = "datex-studio-cli"
 CACHE_TTL_SECONDS = 24 * 60 * 60
-PROMPT_DEDUPE_SECONDS = 60 * 60  # at most one prompt per hour per machine
+NOTIFY_DEDUPE_SECONDS = 60 * 60  # at most one banner per hour per machine
 HTTP_TIMEOUT_SECONDS = 2.0
 
 _CI_ENV_VARS = ("CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "BUILDKITE", "TF_BUILD")
@@ -145,58 +148,44 @@ def detect_upgrade_command() -> str:
     return f"{exe} -m pip install --upgrade {PACKAGE_NAME}"
 
 
-def _run_upgrade(command: str) -> int:
-    """Replace this process with the upgrade command.
-
-    Using ``os.execvp`` is intentional: it tears down the running ``dxs``
-    process before the upgrade tool (uv/pipx/pip) starts rewriting the venv,
-    avoiding "file in use" conflicts where the upgrader can't replace the
-    binary or package files while ``dxs`` is still running.
+def _stderr_is_tty() -> bool:
+    """True when stderr is attached to a TTY.
 
-    On success this function does not return — the process image is replaced.
-    Returns 1 only when exec itself fails to start.
+    Only stderr matters — the banner is written there. Piping stdout (e.g.
+    ``dxs odata ... | jq``) leaves stderr untouched, so the user still sees
+    the banner in their terminal. Redirecting stderr (``2>log``) suppresses
+    it, as intended.
     """
-    click.echo(f"Running: {command}", err=True)
-    try:
-        sys.stdout.flush()
-        sys.stderr.flush()
-    except Exception:  # noqa: BLE001
-        pass
-
-    args = shlex.split(command)
-    if not args:
-        click.echo("Upgrade command was empty.", err=True)
-        return 1
-    try:
-        os.execvp(args[0], args)
-    except OSError as e:
-        click.echo(f"Upgrade failed to start: {e}", err=True)
-        return 1
-    return 1  # unreachable on success
+    return sys.stderr.isatty()
 
 
-def _interactive() -> bool:
-    """True only when stdin, stderr, and stdout are all attached to a TTY.
-
-    We require stdout TTY too, because piping/redirecting stdout is the strongest
-    signal that the user is consuming structured output programmatically and
-    won't appreciate a banner mid-stream.
-    """
-    return all(s.isatty() for s in (sys.stdin, sys.stderr, sys.stdout))
+def _print_banner(latest: str, upgrade_cmd: str) -> None:
+    """Print the update banner to stderr."""
+    click.echo("", err=True)
+    click.echo(
+        f"  A new release of dxs is available: {__version__} → {latest}",
+        err=True,
+    )
+    click.echo(f"  To upgrade, run: {upgrade_cmd}", err=True)
+    click.echo(f"  https://pypi.org/project/{PACKAGE_NAME}/{latest}/", err=True)
 
 
 def maybe_show_update_notice(skip: bool = False) -> None:
-    """Check the cache and, if a newer version is available, prompt to upgrade.
+    """If the cache shows a newer version, print a one-time banner to stderr.
 
-    Always returns quickly — the network fetch happens in a background thread.
+    Always returns quickly — the PyPI fetch happens in a background thread
+    that only writes to the cache. The first run on a stale cache prints
+    nothing; the next run sees the refreshed cache and prints the banner.
+    Dedupe keeps it to one banner per ``NOTIFY_DEDUPE_SECONDS`` window so
+    fast-fire commands don't spam.
 
     Args:
-        skip: If True, skip both the check and any cache refresh. Used to honor
-            ``--no-update-check``.
+        skip: If True, skip both the check and any cache refresh. Used to
+            honor ``--no-update-check``.
     """
     if skip or is_disabled() or _is_ci():
         return
-    if not _interactive():
+    if not _stderr_is_tty():
         return
 
     cache = _read_cache()
@@ -209,30 +198,11 @@ def maybe_show_update_notice(skip: bool = False) -> None:
     if not isinstance(latest, str) or not is_newer(latest, __version__):
         return
 
-    last_prompted = float(cache.get("last_prompted_at", 0))
-    if time.time() - last_prompted < PROMPT_DEDUPE_SECONDS:
+    last_notified = float(cache.get("last_notified_at", 0))
+    if time.time() - last_notified < NOTIFY_DEDUPE_SECONDS:
         return
 
-    upgrade_cmd = detect_upgrade_command()
-    click.echo("", err=True)
-    click.echo(
-        f"  dxs {latest} is available (you have {__version__})",
-        err=True,
-    )
-    click.echo(f"  Upgrade command: {upgrade_cmd}", err=True)
+    _print_banner(latest, detect_upgrade_command())
 
-    cache["last_prompted_at"] = time.time()
+    cache["last_notified_at"] = time.time()
     _write_cache(cache)
-
-    try:
-        if click.confirm("  Upgrade now?", default=False, err=True):
-            click.echo(
-                "  After upgrade completes, re-run your dxs command to use the new version.",
-                err=True,
-            )
-            exit_code = _run_upgrade(upgrade_cmd)
-            # _run_upgrade only returns when exec failed to start.
-            click.echo(f"  Upgrade exited with code {exit_code}.", err=True)
-    except (click.Abort, EOFError):
-        click.echo("", err=True)
-        return