boxd 0.1.1.dev5__tar.gz → 0.1.1.dev7__tar.gz

{boxd-0.1.1.dev5/src/boxd.egg-info → boxd-0.1.1.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boxd
-Version: 0.1.1.dev5
+Version: 0.1.1.dev7
 Summary: Python SDK for the boxd cloud VM platform
 Author: Azin
 License-Expression: MIT
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: grpcio>=1.60
 Requires-Dist: protobuf>=4.25
-Requires-Dist: httpx>=0.27
+Requires-Dist: httpx<1,>=0.27
 Provides-Extra: dev
 Requires-Dist: grpcio-tools>=1.60; extra == "dev"
 Requires-Dist: pytest>=8; extra == "dev"

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "boxd"
-version = "0.1.1.dev5"
+version = "0.1.1.dev7"
 description = "Python SDK for the boxd cloud VM platform"
 readme = "README.md"
 license = "MIT"
@@ -22,7 +22,13 @@ classifiers = [
 dependencies = [
     "grpcio>=1.60",
     "protobuf>=4.25",
-    "httpx>=0.27",
+    # Cap below 1.0: httpx 1.0 (currently in pre-release as 1.0.devN)
+    # removed `httpx.AsyncClient`, which auth.py uses for the API-key →
+    # JWT exchange. Without this cap, anyone running `pip install --pre
+    # boxd` (necessary for staging dev builds) gets httpx 1.0.devN and
+    # the SDK crashes on the first call. Re-evaluate when httpx 1.0 ships
+    # stable and the AsyncClient migration path is documented.
+    "httpx>=0.27,<1",
 ]
 
 [project.urls]

boxd-0.1.1.dev7/src/boxd/_version_check.py

@@ -0,0 +1,169 @@
+"""SDK update notice — piggybacks on every gRPC call's metadata.
+
+The proxy attaches `x-boxd-py-sdk-latest` to response initial metadata when
+a newer SDK version is available. We send `x-boxd-py-sdk-version` outbound
+so the server can log who's calling. On the first response that carries a
+strictly-newer latest version, we print a one-time stderr nag.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+import grpc
+import grpc.aio
+
+REQ_HEADER = "x-boxd-py-sdk-version"
+RESP_HEADER = "x-boxd-py-sdk-latest"
+UPGRADE_CMD = "pip install --upgrade boxd"
+
+_notified = False
+
+
+def _current_version() -> str:
+    # Late import so this module is importable from inside the package
+    # without circular-import drama (boxd/__init__.py imports a lot).
+    from . import __version__
+
+    return __version__
+
+
+class VersionCheckInterceptor(
+    grpc.aio.UnaryUnaryClientInterceptor,
+    grpc.aio.UnaryStreamClientInterceptor,
+    grpc.aio.StreamUnaryClientInterceptor,
+    grpc.aio.StreamStreamClientInterceptor,
+):
+    """Adds outbound SDK-version header, watches inbound for an upgrade hint."""
+
+    def _add_version(self, client_call_details):
+        metadata = list(client_call_details.metadata or [])
+        metadata.append((REQ_HEADER, _current_version()))
+        return client_call_details._replace(metadata=metadata)
+
+    async def _maybe_notify_from_call(self, call):
+        global _notified
+        if _notified:
+            return
+        try:
+            md = await call.initial_metadata()
+        except Exception:
+            return
+        if md is None:
+            return
+        latest = None
+        for key, value in md:
+            if key.lower() == RESP_HEADER:
+                latest = value.strip() if isinstance(value, str) else None
+                break
+        if not latest:
+            return
+        current = _current_version()
+        if _compare_semver(latest, current) <= 0:
+            return
+        _notified = True
+        print(file=sys.stderr)
+        print(
+            f"  A new version of boxd is available (v{latest}, you have v{current}). Update with:",
+            file=sys.stderr,
+        )
+        print(f"    {UPGRADE_CMD}", file=sys.stderr)
+
+    async def intercept_unary_unary(self, continuation, client_call_details, request):
+        new_details = self._add_version(client_call_details)
+        call = await continuation(new_details, request)
+        await self._maybe_notify_from_call(call)
+        return call
+
+    async def intercept_unary_stream(self, continuation, client_call_details, request):
+        new_details = self._add_version(client_call_details)
+        call = await continuation(new_details, request)
+        await self._maybe_notify_from_call(call)
+        return call
+
+    async def intercept_stream_unary(
+        self, continuation, client_call_details, request_iterator
+    ):
+        new_details = self._add_version(client_call_details)
+        call = await continuation(new_details, request_iterator)
+        await self._maybe_notify_from_call(call)
+        return call
+
+    async def intercept_stream_stream(
+        self, continuation, client_call_details, request_iterator
+    ):
+        new_details = self._add_version(client_call_details)
+        call = await continuation(new_details, request_iterator)
+        await self._maybe_notify_from_call(call)
+        return call
+
+
+_SEMVER_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)(.*)$")
+_SUFFIX_SEPARATORS_RE = re.compile(r"[.-]")
+_SUFFIX_LETTER_DIGIT_RE = re.compile(r"(?<=\D)(?=\d)|(?<=\d)(?=\D)")
+
+
+def _compare_semver(a: str, b: str) -> int:
+    """Return >0 if a > b, <0 if a < b, 0 if equal/unparseable.
+
+    Handles pre-release suffixes ("0.1.1-dev.4", "0.1.1.dev4") by
+    component-wise compare, numeric where both components are all-digits.
+    A release (no suffix) ranks above any pre-release of the same
+    numeric prefix. Unparseable input returns 0 — never nag on garbage.
+    """
+    pa = _SEMVER_RE.match(a.strip())
+    pb = _SEMVER_RE.match(b.strip())
+    if not pa or not pb:
+        return 0
+    for i in range(1, 4):
+        ai, bi = int(pa.group(i)), int(pb.group(i))
+        if ai != bi:
+            return ai - bi
+    sa, sb = pa.group(4) or "", pb.group(4) or ""
+    if sa == "" and sb != "":
+        return 1
+    if sa != "" and sb == "":
+        return -1
+    return _compare_suffix(sa, sb)
+
+
+def _compare_suffix(a: str, b: str) -> int:
+    if a == b:
+        return 0
+    parts_a = _parse_suffix(a)
+    parts_b = _parse_suffix(b)
+    for i in range(max(len(parts_a), len(parts_b))):
+        pa = parts_a[i] if i < len(parts_a) else None
+        pb = parts_b[i] if i < len(parts_b) else None
+        if pa is None:
+            return -1  # shorter prerelease ranks lower
+        if pb is None:
+            return 1
+        na = int(pa) if pa.isdigit() else None
+        nb = int(pb) if pb.isdigit() else None
+        if na is not None and nb is not None:
+            if na != nb:
+                return na - nb
+        elif na is not None:
+            return -1  # numeric < alphanumeric (SemVer §11.4.3)
+        elif nb is not None:
+            return 1
+        elif pa != pb:
+            return -1 if pa < pb else 1
+    return 0
+
+
+def _parse_suffix(s: str) -> list[str]:
+    """Decompose "-dev.6" / ".dev6" into ["dev", "6"]."""
+    if not s:
+        return []
+    stripped = s.lstrip("-.")
+    if not stripped:
+        return []
+    components: list[str] = []
+    for piece in _SUFFIX_SEPARATORS_RE.split(stripped):
+        if not piece:
+            continue
+        components.extend(p for p in _SUFFIX_LETTER_DIGIT_RE.split(piece) if p)
+    return components

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7}/src/boxd/client.py

@@ -9,6 +9,7 @@ import grpc.aio
 
 from ._generated import api_pb2, api_pb2_grpc
 from ._utils import resolve_endpoint
+from ._version_check import VersionCheckInterceptor
 from .auth import TokenAuth
 from .boxes import BoxService
 from .disks import DiskService
@@ -109,7 +110,7 @@ class Compute:
         if self._stub is not None:
             return self._stub
 
-        interceptor = self._auth.interceptor()
+        interceptors = [self._auth.interceptor(), VersionCheckInterceptor()]
         endpoint = resolve_endpoint(self._api_url)
 
         if endpoint.use_tls:
@@ -117,12 +118,12 @@ class Compute:
             channel = grpc.aio.secure_channel(
                 endpoint.host,
                 creds,
-                interceptors=[interceptor],
+                interceptors=interceptors,
             )
         else:
             channel = grpc.aio.insecure_channel(
                 endpoint.host,
-                interceptors=[interceptor],
+                interceptors=interceptors,
             )
 
         self._channel = channel

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7/src/boxd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boxd
-Version: 0.1.1.dev5
+Version: 0.1.1.dev7
 Summary: Python SDK for the boxd cloud VM platform
 Author: Azin
 License-Expression: MIT
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: grpcio>=1.60
 Requires-Dist: protobuf>=4.25
-Requires-Dist: httpx>=0.27
+Requires-Dist: httpx<1,>=0.27
 Provides-Extra: dev
 Requires-Dist: grpcio-tools>=1.60; extra == "dev"
 Requires-Dist: pytest>=8; extra == "dev"

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7}/src/boxd.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/boxd/__init__.py
 src/boxd/_sync.py
 src/boxd/_utils.py
+src/boxd/_version_check.py
 src/boxd/aio.py
 src/boxd/auth.py
 src/boxd/box.py
@@ -34,4 +35,5 @@ tests/test_files.py
 tests/test_lifecycle.py
 tests/test_proxies.py
 tests/test_utils.py
-tests/test_v2.py
+tests/test_v2.py
+tests/test_version_check.py

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7}/src/boxd.egg-info/requires.txt

@@ -1,6 +1,6 @@
 grpcio>=1.60
 protobuf>=4.25
-httpx>=0.27
+httpx<1,>=0.27
 
 [dev]
 grpcio-tools>=1.60

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7}/tests/test_e2e.py

@@ -206,6 +206,16 @@ def test_suspend_resume(compute):
         assert result.suspend_us > 0
         assert box.status == "suspended"
 
+        # SuspendVm currently returns before the raft commit landing the new
+        # status is applied (~250ms gap on staging). ResumeVm's admission
+        # check then sees status=running and rejects. Poll the server view
+        # until it agrees the VM is suspended before attempting resume.
+        # Track: server-side fix to make SuspendVm block until commit-applied.
+        for _ in range(20):
+            if compute.box.get(box.id).status == "suspended":
+                break
+            time.sleep(0.25)
+
         result = box.resume()
         assert result.resume_us > 0
         assert box.status == "running"

{boxd-0.1.1.dev5 → boxd-0.1.1.dev7}/tests/test_v2.py

@@ -52,9 +52,11 @@ def test_token_roundtrip(compute):
     original_user = compute.whoami().user_id
 
     token = compute.token.create(expires_in=3600)
+    # Reuse the parent compute's endpoints so the test works against any
+    # cluster (localhost dev, staging, production), not just localhost.
     with Compute(
         token=token.token,
-        api_url="localhost:9443",
-        exchange_url="http://localhost:8080/api/v1/auth/token",
+        api_url=compute._api_url,
+        exchange_url=compute._exchange_url,
     ) as c2:
         assert c2.whoami().user_id == original_user

boxd-0.1.1.dev7/tests/test_version_check.py

@@ -0,0 +1,178 @@
+"""Unit tests for boxd._version_check — semver compare + interceptor metadata behavior."""
+
+from __future__ import annotations
+
+import pytest
+from grpc.aio import ClientCallDetails
+
+from boxd import _version_check
+from boxd._version_check import (
+    REQ_HEADER,
+    RESP_HEADER,
+    VersionCheckInterceptor,
+    _compare_semver,
+)
+
+# Picked to be unambiguously newer/older than any real shipped SDK so tests
+# don't silently flip meaning when the package version bumps.
+NEWER = "99.0.0"
+OLDER = "0.0.1"
+CURRENT = "0.1.1"
+
+
+@pytest.fixture(autouse=True)
+def reset_notified():
+    _version_check._notified = False
+    yield
+    _version_check._notified = False
+
+
+@pytest.fixture
+def stub_current(monkeypatch):
+    monkeypatch.setattr(_version_check, "_current_version", lambda: CURRENT)
+
+
+@pytest.fixture
+def interceptor():
+    return VersionCheckInterceptor()
+
+
+def _details(metadata):
+    return ClientCallDetails(
+        method="/test/Method",
+        timeout=None,
+        metadata=metadata,
+        credentials=None,
+        wait_for_ready=None,
+    )
+
+
+def _make_call(metadata):
+    class FakeCall:
+        async def initial_metadata(self):
+            return metadata
+
+    return FakeCall()
+
+
+# --- _compare_semver ---
+
+
+def test_compare_semver_patch_greater():
+    assert _compare_semver("0.1.1", "0.1.0") > 0
+
+
+def test_compare_semver_patch_lesser():
+    assert _compare_semver("0.1.0", "0.1.1") < 0
+
+
+def test_compare_semver_equal():
+    assert _compare_semver("0.1.0", "0.1.0") == 0
+
+
+def test_compare_semver_major_dominates_minor():
+    assert _compare_semver("1.0.0", "0.99.99") > 0
+
+
+def test_compare_semver_minor_dominates_patch():
+    assert _compare_semver("0.2.0", "0.1.99") > 0
+
+
+def test_compare_semver_release_greater_than_prerelease():
+    assert _compare_semver("0.1.1", "0.1.1-dev.4") > 0
+    assert _compare_semver("0.1.1-dev.4", "0.1.1") < 0
+
+
+def test_compare_semver_prerelease_lex_order():
+    assert _compare_semver("0.1.1-dev.4", "0.1.1-dev.5") < 0
+    assert _compare_semver("0.1.1-dev.5", "0.1.1-dev.4") > 0
+
+
+def test_compare_semver_unparseable_returns_zero():
+    assert _compare_semver("garbage", "0.1.0") == 0
+    assert _compare_semver("0.1.0", "garbage") == 0
+    assert _compare_semver("v1.0.0", "0.1.0") == 0
+    assert _compare_semver("", "0.1.0") == 0
+
+
+def test_compare_semver_whitespace_tolerated():
+    assert _compare_semver("  0.1.1  ", "0.1.0") > 0
+
+
+# --- VersionCheckInterceptor._add_version ---
+
+
+def test_add_version_appends_header(stub_current, interceptor):
+    new = interceptor._add_version(_details([]))
+    assert (REQ_HEADER, CURRENT) in new.metadata
+
+
+def test_add_version_preserves_existing_metadata(stub_current, interceptor):
+    new = interceptor._add_version(_details([("authorization", "Bearer abc")]))
+    assert ("authorization", "Bearer abc") in new.metadata
+    assert (REQ_HEADER, CURRENT) in new.metadata
+
+
+def test_add_version_handles_none_metadata(stub_current, interceptor):
+    new = interceptor._add_version(_details(None))
+    assert new.metadata == [(REQ_HEADER, CURRENT)]
+
+
+# --- VersionCheckInterceptor._maybe_notify_from_call ---
+
+
+async def test_maybe_notify_warns_when_latest_greater(stub_current, interceptor, capsys):
+    await interceptor._maybe_notify_from_call(_make_call([(RESP_HEADER, NEWER)]))
+    err = capsys.readouterr().err
+    assert NEWER in err
+    assert CURRENT in err
+    assert "pip install --upgrade boxd" in err
+    assert _version_check._notified is True
+
+
+@pytest.mark.parametrize(
+    "metadata",
+    [
+        pytest.param([(RESP_HEADER, CURRENT)], id="latest-equal"),
+        pytest.param([(RESP_HEADER, OLDER)], id="latest-older"),
+        pytest.param([("other-header", "value")], id="header-missing"),
+        pytest.param([], id="metadata-empty"),
+        pytest.param(None, id="metadata-none"),
+        pytest.param([(RESP_HEADER, "   ")], id="header-whitespace-only"),
+    ],
+)
+async def test_maybe_notify_silent(stub_current, interceptor, capsys, metadata):
+    await interceptor._maybe_notify_from_call(_make_call(metadata))
+    assert capsys.readouterr().err == ""
+    assert _version_check._notified is False
+
+
+async def test_maybe_notify_silent_when_initial_metadata_raises(
+    stub_current, interceptor, capsys
+):
+    class FailingCall:
+        async def initial_metadata(self):
+            raise RuntimeError("connection lost")
+
+    await interceptor._maybe_notify_from_call(FailingCall())
+    assert capsys.readouterr().err == ""
+
+
+async def test_maybe_notify_warns_only_once(stub_current, interceptor, capsys):
+    call = _make_call([(RESP_HEADER, NEWER)])
+    await interceptor._maybe_notify_from_call(call)
+    assert NEWER in capsys.readouterr().err
+    await interceptor._maybe_notify_from_call(call)
+    assert capsys.readouterr().err == ""
+
+
+async def test_maybe_notify_case_insensitive_header(stub_current, interceptor, capsys):
+    await interceptor._maybe_notify_from_call(_make_call([("X-Boxd-Py-Sdk-Latest", NEWER)]))
+    assert NEWER in capsys.readouterr().err
+
+
+async def test_maybe_notify_strips_whitespace_in_header_value(
+    stub_current, interceptor, capsys
+):
+    await interceptor._maybe_notify_from_call(_make_call([(RESP_HEADER, f"  {NEWER}  ")]))
+    assert NEWER in capsys.readouterr().err