levers9 0.2.1__tar.gz → 0.2.2__tar.gz

{levers9-0.2.1 → levers9-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: levers9
-Version: 0.2.1
+Version: 0.2.2
 Summary: levers9 SDK and CLI: run jobs, endpoints, queues, crons, boxes and GPU work on a levers9 cluster
 Author-email: Levers AI Lab <hello@uselevers.com>
 Requires-Python: <4.0,>=3.8

{levers9-0.2.1 → levers9-0.2.2}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
     "pyyaml<7.0.0,>=6.0.0",
 ]
 name = "levers9"
-version = "0.2.1"
+version = "0.2.2"
 description = "levers9 SDK and CLI: run jobs, endpoints, queues, crons, boxes and GPU work on a levers9 cluster"
 
 [project.scripts]

{levers9-0.2.1 → levers9-0.2.2}/src/levers9/cli/update_check.py

@@ -22,6 +22,7 @@ from typing import Optional, Tuple
 PACKAGE = "levers9"
 PYPI_URL = f"https://pypi.org/pypi/{PACKAGE}/json"
 CHECK_INTERVAL_S = 24 * 60 * 60
+NOTIFY_INTERVAL_S = 24 * 60 * 60
 NETWORK_TIMEOUT_S = 2.0
 
 
@@ -36,15 +37,26 @@ def _read_cache() -> dict:
         return {}
 
 
-def _write_cache(latest: str) -> None:
+def _write_cache(latest: str, **extra) -> None:
     try:
         p = _cache_path()
         p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(json.dumps({"latest": latest, "checked_at": time.time()}))
+        data = {**_read_cache(), "latest": latest, "checked_at": time.time(), **extra}
+        p.write_text(json.dumps(data))
     except OSError:
         pass  # read-only home, no disk: not worth a word
 
 
+def _mark_notified() -> None:
+    try:
+        p = _cache_path()
+        data = {**_read_cache(), "notified_at": time.time()}
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(json.dumps(data))
+    except OSError:
+        pass
+
+
 def _installed_version() -> Optional[str]:
     try:
         from importlib.metadata import version
@@ -138,7 +150,14 @@ def _refresh_in_background() -> None:
 
 
 def disabled() -> bool:
-    return bool(os.getenv("LEVERS9_NO_UPDATE_CHECK") or os.getenv("CI"))
+    if os.getenv("LEVERS9_NO_UPDATE_CHECK") or os.getenv("CI"):
+        return True
+    # Nothing is read by a person when output is being captured, and a notice written into a pipe is
+    # corruption rather than help: `levers9 ls > out.json` must produce only the json.
+    try:
+        return not sys.stderr.isatty()
+    except Exception:
+        return True
 
 
 def notice() -> Optional[str]:
@@ -158,6 +177,11 @@ def notice() -> Optional[str]:
     if not latest or not is_newer(latest, installed):
         return None
 
+    # Say it once a day, not once a command. Someone running twenty commands does not need telling twenty
+    # times, and a notice that repeats is one people learn to read past.
+    if time.time() - float(cache.get("notified_at") or 0) < NOTIFY_INTERVAL_S:
+        return None
+
     return f"levers9 {latest} is available (you have {installed}) · uv tool upgrade levers9"
 
 
@@ -167,8 +191,8 @@ def print_notice() -> None:
         line = notice()
         if not line:
             return
-        from .. import terminal
-
-        terminal.detail(line)
+        # stderr, so it never lands in output a caller is parsing
+        print(f"\n\033[2m{line}\033[0m", file=sys.stderr)
+        _mark_notified()
     except Exception:
         pass

{levers9-0.2.1 → levers9-0.2.2}/src/levers9/client/client.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 import requests
 
-from ..config import get_config_context, get_settings
+from ..config import DEFAULT_API_HOST, get_config_context, get_settings
 from ..env import is_remote
 from ..exceptions import VolumeUploadError, WorkspaceNotFoundError
 from . import get, make_request
@@ -42,11 +42,25 @@ class Client:
             if not self.token:
                 self.token = config_context.token
 
+            # api_host is a dataclass default, not read from the environment, so it is 0.0.0.0 unless a
+            # caller passes one — which meant every REST call went to 0.0.0.0:1994 and only worked when the
+            # controlplane happened to be local. Prefer an explicit override, then the context the CLI and
+            # the dashboard already write, and keep the old default as the last resort.
             if not controlplane_host:
-                self.controlplane_host = settings.api_host
+                self.controlplane_host = (
+                    os.environ.get("LEVERS9_API_HOST")
+                    or (config_context.controlplane_host if settings.api_host == DEFAULT_API_HOST else settings.api_host)
+                    or settings.api_host
+                )
 
             if not controlplane_port:
-                self.controlplane_port = settings.api_port
+                override = os.environ.get("LEVERS9_API_PORT")
+                if override:
+                    self.controlplane_port = int(override)
+                elif config_context.controlplane_port == 443:
+                    self.controlplane_port = 443      # TLS front door: REST and gRPC share it
+                else:
+                    self.controlplane_port = settings.api_port
 
         if not self.tls and self.controlplane_port == 443:
             self.tls = True

{levers9-0.2.1 → levers9-0.2.2}/src/levers9/config.py

@@ -71,9 +71,19 @@ class ConfigContext:
     controlplane_host: Optional[str] = None
     controlplane_port: Optional[int] = None
 
+    # A config written before the rename spells these gateway_*. Every load comes through from_dict, and
+    # unknown keys are dropped here, so without this the old names vanish on read - and the next command
+    # that saves writes the file back with the host blank, quietly losing every context but the one in use.
+    _RENAMED = {"gateway_host": "controlplane_host", "gateway_port": "controlplane_port"}
+
     @classmethod
     def from_dict(cls, data: Mapping[str, Any]) -> "ConfigContext":
-        return cls(**{k: v for k, v in data.items() if k in inspect.signature(cls).parameters})
+        fields = inspect.signature(cls).parameters
+        out = {k: v for k, v in data.items() if k in fields}
+        for was, now in cls._RENAMED.items():
+            if data.get(was) and not out.get(now):
+                out[now] = data[was]
+        return cls(**out)
 
     def to_dict(self) -> MutableMapping[str, Any]:
         return {k: ("" if not v else v) for k, v in asdict(self).items()}

{levers9-0.2.1 → levers9-0.2.2}/src/levers9.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: levers9
-Version: 0.2.1
+Version: 0.2.2
 Summary: levers9 SDK and CLI: run jobs, endpoints, queues, crons, boxes and GPU work on a levers9 cluster
 Author-email: Levers AI Lab <hello@uselevers.com>
 Requires-Python: <4.0,>=3.8

{levers9-0.2.1 → levers9-0.2.2}/src/levers9.egg-info/SOURCES.txt

@@ -140,6 +140,8 @@ src/levers9/vendor/pathspec/patterns/__init__.py
 src/levers9/vendor/pathspec/patterns/gitwildmatch.py
 tests/test_capacity.py
 tests/test_cli.py
+tests/test_client_base_url.py
+tests/test_config.py
 tests/test_container_runner.py
 tests/test_deployment.py
 tests/test_env.py

levers9-0.2.2/tests/test_client_base_url.py

@@ -0,0 +1,38 @@
+"""The REST client must reach the configured controlplane, not 0.0.0.0."""
+
+import os
+import unittest
+from unittest import mock
+
+
+class BaseUrl(unittest.TestCase):
+    def _client(self, env=None, ctx_host="levers9-controlplane", ctx_port=1993):
+        from levers9.client.client import Client
+        from levers9.config import ConfigContext
+
+        with mock.patch.dict(os.environ, env or {}, clear=False), mock.patch(
+            "levers9.client.client.get_config_context",
+            return_value=ConfigContext(
+                token="t", controlplane_host=ctx_host, controlplane_port=ctx_port
+            ),
+        ), mock.patch(
+            "levers9.client.client.Client._load_workspace", lambda self: None
+        ), mock.patch("levers9.client.client.is_remote", return_value=False):
+            return Client(token="t")
+
+    def test_uses_the_configured_host_not_the_default(self):
+        c = self._client()
+        self.assertIn("levers9-controlplane", c.base_url)
+        self.assertNotIn("0.0.0.0", c.base_url)
+
+    def test_explicit_env_wins(self):
+        c = self._client(env={"LEVERS9_API_HOST": "rest.example", "LEVERS9_API_PORT": "8080"})
+        self.assertIn("rest.example:8080", c.base_url)
+
+    def test_tls_front_door_keeps_443(self):
+        c = self._client(ctx_host="levers9-grpc.uselevers.com", ctx_port=443)
+        self.assertTrue(c.base_url.startswith("https://"), c.base_url)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

levers9-0.2.2/tests/test_config.py

@@ -0,0 +1,60 @@
+"""The config file survives a round trip, including one written before the gateway -> controlplane rename."""
+
+import configparser
+from pathlib import Path
+
+from levers9.config import ConfigContext, load_config, save_config
+
+OLD_FORMAT = """\
+[default]
+token = tok-default
+gateway_host = levers9-grpc.uselevers.com
+gateway_port = 443
+
+[local]
+token = tok-local
+gateway_host = localhost
+gateway_port = 1993
+
+[staging]
+token = tok-staging
+gateway_host = staging.uselevers.com
+gateway_port = 443
+"""
+
+
+def test_old_key_names_are_read(tmp_path: Path):
+    path = tmp_path / "config"
+    path.write_text(OLD_FORMAT)
+
+    contexts = load_config(path)
+
+    assert contexts["local"].controlplane_host == "localhost"
+    # configparser hands back strings, which is what the new spelling yields too; use_ssl() takes either.
+    assert str(contexts["local"].controlplane_port) == "1993"
+    assert contexts["staging"].controlplane_host == "staging.uselevers.com"
+
+
+def test_saving_does_not_blank_the_contexts_it_did_not_touch(tmp_path: Path):
+    """The regression: unknown keys were dropped on load, so the next save wrote every host back empty."""
+    path = tmp_path / "config"
+    path.write_text(OLD_FORMAT)
+
+    contexts = load_config(path)
+    save_config(contexts, path)
+
+    parser = configparser.ConfigParser(default_section="default")
+    parser.read(path)
+
+    assert parser["local"]["controlplane_host"] == "localhost"
+    assert parser["local"]["controlplane_port"] == "1993"
+    assert parser["staging"]["controlplane_host"] == "staging.uselevers.com"
+    assert parser["staging"]["token"] == "tok-staging"
+
+
+def test_the_new_spelling_wins_when_a_config_carries_both(tmp_path: Path):
+    ctx = ConfigContext.from_dict(
+        {"token": "t", "controlplane_host": "new.example", "gateway_host": "old.example"}
+    )
+
+    assert ctx.controlplane_host == "new.example"

{levers9-0.2.1 → levers9-0.2.2}/tests/test_update_check.py

@@ -1,5 +1,9 @@
 """The behaviours that matter: never blocks, never fails a command, never nags wrongly."""
-import json, os, sys, time, types, unittest
+
+import json
+import os
+import time
+import unittest
 from pathlib import Path
 from unittest import mock
 
@@ -8,7 +12,12 @@ from levers9.cli import update_check as uc
 
 class VersionCompare(unittest.TestCase):
     def test_newer_is_detected(self):
-        for latest, installed in [("0.2.0", "0.1.272"), ("1.0.0", "0.9.9"), ("0.2.1", "0.2.0"), ("0.10.0", "0.9.0")]:
+        for latest, installed in [
+            ("0.2.0", "0.1.272"),
+            ("1.0.0", "0.9.9"),
+            ("0.2.1", "0.2.0"),
+            ("0.10.0", "0.9.0"),
+        ]:
             self.assertTrue(uc.is_newer(latest, installed), f"{latest} > {installed}")
 
     def test_same_or_older_is_not(self):
@@ -25,25 +34,32 @@ class VersionCompare(unittest.TestCase):
 
 class Notice(unittest.TestCase):
     def setUp(self):
-        self.tmp = Path(os.environ["TMPDIR"] if "TMPDIR" in os.environ else "/tmp") / f"uc-{time.time_ns()}"
+        self.tmp = Path(os.environ.get("TMPDIR", "/tmp")) / f"uc-{time.time_ns()}"
         self.tmp.mkdir(parents=True, exist_ok=True)
         self.patches = [
             mock.patch.object(uc, "_cache_path", lambda: self.tmp / "update-check.json"),
             mock.patch.object(uc, "_installed_version", lambda: "0.1.272"),
             mock.patch.dict(os.environ, {"LEVERS9_NO_UPDATE_CHECK": "", "CI": ""}, clear=False),
+            mock.patch("sys.stderr.isatty", lambda: True),
         ]
-        for p in self.patches: p.start()
+        for patch in self.patches:
+            patch.start()
 
     def tearDown(self):
-        for p in self.patches: p.stop()
+        for patch in self.patches:
+            patch.stop()
 
     def _cache(self, latest, age_s=0):
-        (self.tmp / "update-check.json").write_text(json.dumps({"latest": latest, "checked_at": time.time() - age_s}))
+        (self.tmp / "update-check.json").write_text(
+            json.dumps({"latest": latest, "checked_at": time.time() - age_s})
+        )
 
     def test_fresh_cache_with_newer_version_notifies(self):
         self._cache("0.2.0")
         n = uc.notice()
-        self.assertIn("0.2.0", n); self.assertIn("0.1.272", n); self.assertIn("upgrade", n)
+        self.assertIn("0.2.0", n)
+        self.assertIn("0.1.272", n)
+        self.assertIn("upgrade", n)
 
     def test_same_version_is_silent(self):
         self._cache("0.1.272")
@@ -53,7 +69,7 @@ class Notice(unittest.TestCase):
         started = time.monotonic()
         with mock.patch.object(uc, "_refresh_in_background") as bg:
             self.assertIsNone(uc.notice())
-            bg.assert_called_once()          # refresh is scheduled for next time
+            bg.assert_called_once()  # refresh is scheduled for next time
         self.assertLess(time.monotonic() - started, 0.1, "notice() must not wait on anything")
 
     def test_stale_cache_still_uses_what_it_has(self):
@@ -73,9 +89,31 @@ class Notice(unittest.TestCase):
         with mock.patch.object(uc, "_refresh_in_background"):
             self.assertIsNone(uc.notice())
 
+    def test_repeats_at_most_once_a_day(self):
+        self._cache("0.2.0")
+        self.assertIsNotNone(uc.notice(), "the first look should speak")
+        uc._mark_notified()
+        self.assertIsNone(uc.notice(), "the second should not")
+
+    def test_silent_when_output_is_captured(self):
+        self._cache("0.2.0")
+        with mock.patch("sys.stderr.isatty", lambda: False):
+            self.assertIsNone(uc.notice(), "a pipe must never receive a notice")
+
+    def test_notice_goes_to_stderr_not_stdout(self):
+        import contextlib
+        import io
+
+        self._cache("0.2.0")
+        out, err = io.StringIO(), io.StringIO()
+        with contextlib.redirect_stdout(out), mock.patch("sys.stderr", err):
+            with mock.patch("sys.stderr.isatty", lambda: True, create=True):
+                uc.print_notice()
+        self.assertEqual(out.getvalue(), "", "stdout must stay clean for callers parsing it")
+
     def test_print_notice_never_raises(self):
         with mock.patch.object(uc, "notice", side_effect=RuntimeError("boom")):
-            uc.print_notice()          # must swallow: a notice is never worth failing a command
+            uc.print_notice()  # must swallow: a notice is never worth failing a command
 
     def test_unreachable_pypi_is_silent(self):
         with mock.patch("urllib.request.urlopen", side_effect=OSError("no network")):