ravmem-cli 1.2.0__tar.gz → 1.3.1__tar.gz

{ravmem_cli-1.2.0/ravmem_cli.egg-info → ravmem_cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.2.0
+Version: 1.3.1
 Summary: RavMem CLI — lightweight client for the RavMem code knowledge graph server
 Author-email: RavMem <harpreet.singh@ravmem.com>
 License-Expression: MIT

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ravmem-cli"
-version = "1.2.0"
+version = "1.3.1"
 description = "RavMem CLI — lightweight client for the RavMem code knowledge graph server"
 readme = "README.md"
 requires-python = ">=3.10"

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/ravmem/cli/_common.py

@@ -73,7 +73,7 @@ def wait_for_indexing(client, project_id: str, branch_name: str, job_id: int, wa
 
 
 def _poll_job_with_progress(
-    client, job_id: int, label: str, interval: float = 1.0, timeout: float = 600.0,
+    client, job_id: int, label: str, interval: float = 1.0,
 ) -> dict:
     """Poll a job to completion, rendering a live progress bar (phase + %)
     instead of ``client.poll_job``'s silent loop — which, combined with the
@@ -92,7 +92,6 @@ def _poll_job_with_progress(
     httpx_logger = logging.getLogger("httpx")
     prev_level = httpx_logger.level
     httpx_logger.setLevel(logging.WARNING)
-    deadline = time.monotonic() + timeout
     try:
         with Progress(
             TextColumn("[bold]{task.description}"),
@@ -112,8 +111,7 @@ def _poll_job_with_progress(
                 if status in ("done", "failed", "cancelled"):
                     progress.update(task, completed=100 if status == "done" else pct)
                     return job
-                if time.monotonic() >= deadline:
-                    raise TimeoutError(f"Job {job_id} did not complete within {timeout}s")
+                # No deadline: --wait means until the job ends, and on a large repo embedding alone takes many minutes.
                 time.sleep(interval)
     finally:
         httpx_logger.setLevel(prev_level)

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/ravmem/cli/git_local.py

@@ -56,23 +56,16 @@ def diff_name_status(
 
     Paths are relative to *repo_path*.
     """
+    # NUL separation keeps tabs, spaces and non-ASCII names intact, and --no-renames reports a rename as a delete
+    # plus an add, so the old path is removed and the new one uploaded.
     out = _run(
-        ["git", "diff", "--name-status", base_commit, target], cwd=repo_path,
+        ["git", "diff", "--name-status", "-z", "--no-renames", base_commit, target], cwd=repo_path,
     )
     modified: list[str] = []
     deleted: list[str] = []
-    for line in out.splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        parts = line.split("\t", 1)
-        if len(parts) != 2:
-            continue
-        status, path = parts[0].strip(), parts[1].strip()
-        if status.startswith("D"):
-            deleted.append(path)
-        else:
-            modified.append(path)
+    fields = out.split("\0")
+    for status, path in zip(fields[::2], fields[1::2]):
+        (deleted if status.startswith("D") else modified).append(path)
     return modified, deleted
 
 

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/ravmem/cli/license.py

@@ -47,7 +47,7 @@ def _post_with_key_fallback(client, con: Console, path: str, body: Optional[dict
     try:
         return client.post(path, json=body)
     except RavMemAPIError as exc:
-        if exc.status == 400 and "RAVMEM_LICENSE_KEY is not set" in (exc.detail or ""):
+        if exc.status == 400 and "RAVMEM_LICENSE_KEY is not set" in (exc.detail or "") and not body.get("license_key"):
             con.print("[yellow]Server has no license key on file — enter it to proceed.[/yellow]")
             key = typer.prompt("License key", hide_input=True).strip()
             if not key:
@@ -57,6 +57,37 @@ def _post_with_key_fallback(client, con: Console, path: str, body: Optional[dict
         raise
 
 
+def _license_hint(detail: str) -> Optional[str]:
+    """Map a license-server refusal to the concrete next step for the operator."""
+    d = detail or ""
+    if "LICENSE_REVOKED" in d:
+        return ("This license was revoked. Rotate the key in the console (that un-revokes it and "
+                "issues a new key), then run: ravmem license activate <new-key>")
+    if "LICENSE_KEY_NOT_FOUND" in d or "License key not found" in d or "No account found" in d:
+        return ("The license server doesn't recognise this key. If it was rotated in the console, "
+                "run: ravmem license activate <new-key>")
+    if "ACTIVATION_LIMIT_REACHED" in d:
+        return ("Every seat on this license is in use — possibly by this same machine under a "
+                "previous key. Deactivate the old machine in the console, then retry.")
+    if "SUBSCRIPTION_SUSPENDED" in d:
+        return "The subscription is suspended. Resolve billing in the console, then run: ravmem license renew"
+    if "SUBSCRIPTION_EXPIRED" in d:
+        return "The subscription has expired. Renew it in the console, then run: ravmem license renew"
+    if "No license record found" in d:
+        return "Run: ravmem license activate <key>"
+    return None
+
+
+def _fail(con: Console, prefix: str, exc: Exception, note: Optional[str] = None) -> None:
+    con.print(f"[red]{prefix}: {exc}[/red]")
+    if note:
+        con.print(f"[dim]{note}[/dim]")
+    hint = _license_hint(getattr(exc, "detail", "") or str(exc))
+    if hint:
+        con.print(f"[yellow]-> {hint}[/yellow]")
+    raise typer.Exit(1)
+
+
 # ---------------------------------------------------------------------------
 # ravmem license init
 # ---------------------------------------------------------------------------
@@ -146,19 +177,25 @@ def activate_cmd(
     # that is fine — we just continue to the entitlement step.
     con.print("Sealing license to this machine…")
     sealed_now = False
-    try:
-        client.post("/activate", json={"license_key": key})
-        sealed_now = True
-        con.print("[green]K3 sealed. Waiting for the server to load modules…[/green]")
-    except RavMemAPIError as exc:
-        if exc.status == 404:
-            con.print("[dim]Server already activated — proceeding to entitlement init.[/dim]")
-        else:
-            con.print(f"[red]Activation failed: {exc}[/red]")
+    for attempt in range(3):
+        try:
+            client.post("/activate", json={"license_key": key})
+            sealed_now = True
+            con.print("[green]K3 sealed. Waiting for the server to load modules…[/green]")
+            break
+        except RavMemAPIError as exc:
+            if exc.status == 404:
+                con.print("[dim]Server already activated — proceeding to entitlement init.[/dim]")
+                break
+            _fail(con, "Activation failed", exc)
+        except Exception as exc:
+            # Transient: server still booting, or a network blip to it.
+            if attempt < 2:
+                time.sleep(3)
+                continue
+            con.print(f"[red]Could not reach the server: {exc}[/red]")
+            con.print("[yellow]-> Check it's running ('docker logs ravmem'), then retry.[/yellow]")
             raise typer.Exit(1)
-    except Exception as exc:
-        con.print(f"[red]Could not reach the server: {exc}[/red]")
-        raise typer.Exit(1)
 
     # Phase 2 — wait for the re-exec'd full server to finish loading modules.
     if sealed_now:
@@ -181,44 +218,57 @@ def activate_cmd(
 
     # Phase 3 — store the signed entitlement JWT (idempotent: 409 = already done).
     con.print("Activating entitlements…")
-    init_payload: dict = {"key_hash": key_hash}
+    init_payload: dict = {"key_hash": key_hash, "license_key": key}
     if server_url:
         init_payload["server_url"] = server_url
     try:
         result = client.post("/api/license/init", json=init_payload)
     except RavMemAPIError as exc:
-        if exc.status == 409:
-            # Already initialized — a 409 alone doesn't mean the stored token is
-            # still usable (e.g. a container recreate can make it undecryptable).
-            # Check token_integrity and repair if it isn't "ok" before declaring
-            # success.
-            con.print("[dim]License already initialized — verifying token integrity…[/dim]")
-            try:
-                status_data = client.get("/api/license/status")
-            except RavMemAPIError as exc2:
-                con.print(f"[red]Could not verify license status: {exc2}[/red]")
-                raise typer.Exit(1)
+        if exc.status != 409:
+            _fail(con, "Entitlement init failed", exc)
+
+        # Already initialized. That alone doesn't mean everything is fine: the
+        # stored token may be broken (recreate), the license may be
+        # deactivated/revoked, or the key typed here may differ from the one
+        # this server holds (rotated key, or a typo). Only report "ready" when
+        # all three check out; otherwise re-fetch with the key given here —
+        # the license server validates it either way, and on refusal nothing
+        # stored locally is changed.
+        con.print("[dim]License already initialized — verifying…[/dim]")
+        try:
+            status_data = client.get("/api/license/status")
+        except RavMemAPIError as exc2:
+            _fail(con, "Could not verify license status", exc2)
 
-            integrity = status_data.get("token_integrity")
-            if integrity == "ok":
-                con.print("[bold green]License already initialized — ravmem is ready.[/bold green]")
-                return
+        integrity = status_data.get("token_integrity")
+        status = status_data.get("status")
+        stored_prefix = status_data.get("key_hash_prefix")
+        key_differs = bool(stored_prefix) and not key_hash.startswith(stored_prefix)
 
-            con.print(f"[yellow]Stored token integrity is '{integrity}' — repairing…[/yellow]")
-            try:
-                # Already have the key in scope from this activate call — no
-                # need to prompt again even if the server has nothing on file.
-                repair_result = client.post("/api/license/repair", json={"license_key": key})
-            except RavMemAPIError as exc3:
-                con.print(f"[red]Repair failed: {exc3}[/red]")
-                raise typer.Exit(1)
-
-            con.print("\n[bold green]License repaired. ravmem is ready.[/bold green]")
-            con.print(f"  Status:  {repair_result.get('status')}")
-            con.print(f"  Expires: {repair_result.get('expiry_ts')}")
+        if integrity == "ok" and status in ("ACTIVE", "GRACE_PERIOD") and not key_differs:
+            con.print("[bold green]License already initialized — ravmem is ready.[/bold green]")
             return
-        con.print(f"[red]Entitlement init failed: {exc}[/red]")
-        raise typer.Exit(1)
+
+        if key_differs:
+            con.print("[yellow]This key differs from the one this server is activated with — "
+                      "switching to it…[/yellow]")
+        elif status not in ("ACTIVE", "GRACE_PERIOD"):
+            con.print(f"[yellow]License status is {status} — re-activating…[/yellow]")
+        else:
+            con.print(f"[yellow]Stored token integrity is '{integrity}' — repairing…[/yellow]")
+        try:
+            repair_result = client.post("/api/license/repair", json={"license_key": key})
+        except RavMemAPIError as exc3:
+            _fail(con, "Activation failed", exc3,
+                  note="Your existing license on this server was left unchanged." if key_differs else None)
+
+        if repair_result.get("status") == "rebind_pending":
+            con.print(f"[yellow]{repair_result.get('message')}[/yellow]")
+            raise typer.Exit(1)
+        con.print("\n[bold green]License activated. ravmem is ready.[/bold green]")
+        con.print(f"  Status:  {repair_result.get('status')}")
+        con.print(f"  Expires: {repair_result.get('expiry_ts')}")
+        return
 
     con.print("\n[bold green]License activated. ravmem is ready.[/bold green]")
     con.print(f"  Status:  {result.get('status')}")
@@ -382,6 +432,8 @@ def status_cmd(
     expiry_ts = data.get("expiry_ts")
     table.add_row("Expires", _fmt_ts(expiry_ts) + _days_until(expiry_ts))
     table.add_row("Last heartbeat", _fmt_ts(data.get("last_heartbeat")))
+    if data.get("heartbeat_interval"):
+        table.add_row("Heartbeat every", f"{data['heartbeat_interval']}s (set in the license console)")
     table.add_row("Last server time", _fmt_ts(data.get("last_server_time")))
 
     grace_deadline = data.get("grace_deadline")
@@ -405,6 +457,8 @@ def status_cmd(
         )
     elif status == "GRACE_PERIOD":
         con.print("\n[yellow]⚠ License in grace period. Renew before the grace window closes.[/yellow]")
+    else:
+        _status_hint(con, status)
 
     if status not in ("ACTIVE", "GRACE_PERIOD", "DEACTIVATED"):
         raise typer.Exit(1)
@@ -414,16 +468,31 @@ def status_cmd(
 # ravmem license renew
 # ---------------------------------------------------------------------------
 
+_KEY_OPTION_HELP = (
+    "License key to use. Only needed if the key was rotated in the console "
+    "(this server is then switched onto it), or if the server has no key on file."
+)
+
+
+def _run_recovery(con: Console, path: str, key: Optional[str], failed: str) -> dict:
+    client = _get_client()
+    body = {"license_key": key.strip()} if key and key.strip() else {}
+    try:
+        return _post_with_key_fallback(client, con, path, body)
+    except RavMemAPIError as exc:
+        _fail(con, failed, exc)
+
+
 @app.command("renew")
-def renew_cmd() -> None:
+def renew_cmd(
+    key: Optional[str] = typer.Option(None, "--key", help=_KEY_OPTION_HELP),
+) -> None:
     """Re-activate an expired license against the live license server."""
     con = _console()
-    client = _get_client()
     con.print("Renewing license…")
-    try:
-        result = _post_with_key_fallback(client, con, "/api/license/renew")
-    except RavMemAPIError as exc:
-        con.print(f"[red]Renewal failed: {exc}[/red]")
+    result = _run_recovery(con, "/api/license/renew", key, "Renewal failed")
+    if result.get("status") == "rebind_pending":
+        con.print(f"[yellow]{result.get('message')}[/yellow]")
         raise typer.Exit(1)
     con.print(f"[green]Renewed. Status: {result.get('status')} | Expiry: {result.get('expiry_ts')}[/green]")
 
@@ -433,20 +502,19 @@ def renew_cmd() -> None:
 # ---------------------------------------------------------------------------
 
 @app.command("repair")
-def repair_cmd() -> None:
-    """Re-fetch and re-encrypt the JWT when the stored token is corrupted."""
+def repair_cmd(
+    key: Optional[str] = typer.Option(None, "--key", help=_KEY_OPTION_HELP),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt"),
+) -> None:
+    """Re-fetch a valid license token for this server (broken token, recreated
+    container, deactivated machine, or a key rotated in the console)."""
     con = _console()
-    con.print(
-        "[yellow]This will re-contact the license server using the stored key_hash "
-        "and machine fingerprint. RAVMEM_LICENSE_KEY must be set on the server.[/yellow]"
-    )
-    typer.confirm("Continue?", abort=True)
-
-    client = _get_client()
-    try:
-        result = _post_with_key_fallback(client, con, "/api/license/repair")
-    except RavMemAPIError as exc:
-        con.print(f"[red]Repair failed: {exc}[/red]")
+    if not yes:
+        con.print("[yellow]This re-contacts the license server and replaces this server's stored token.[/yellow]")
+        typer.confirm("Continue?", abort=True)
+    result = _run_recovery(con, "/api/license/repair", key, "Repair failed")
+    if result.get("status") == "rebind_pending":
+        con.print(f"[yellow]{result.get('message')}[/yellow]")
         raise typer.Exit(1)
     con.print(f"[green]Repair complete. Status: {result.get('status')}[/green]")
 
@@ -489,29 +557,43 @@ def check_cmd() -> None:
     table.add_row("Revision", str(data.get("revision", "—")))
     table.add_row("Expires", _fmt_ts(data.get("expiry_ts")))
     table.add_row("Last heartbeat", _fmt_ts(data.get("last_heartbeat")))
+    if data.get("heartbeat_interval"):
+        table.add_row("Heartbeat every", f"{data['heartbeat_interval']}s (set in the license console)")
     grace_deadline = data.get("grace_deadline")
     if grace_deadline:
         table.add_row("[yellow]Grace deadline[/yellow]", f"[yellow]{_fmt_ts(grace_deadline)}[/yellow]")
     con.print(table)
+    _status_hint(con, status)
 
     if status not in ("ACTIVE", "GRACE_PERIOD", "DEACTIVATED", "SUSPENDED"):
         raise typer.Exit(1)
 
 
+def _status_hint(con: Console, status: str) -> None:
+    hints = {
+        "REVOKED": _license_hint("LICENSE_REVOKED"),
+        "REQUIRES_REACTIVATION": "Run: ravmem license repair   (or: ravmem license activate <key>)",
+        "TAMPERED": "Run: ravmem license repair",
+        "DEACTIVATED": "This machine was deactivated. To keep it, run: ravmem license activate <key>",
+        "SUSPENDED": _license_hint("SUBSCRIPTION_SUSPENDED"),
+        "UNINITIALIZED": "Run: ravmem license activate <key>",
+    }
+    if hints.get(status):
+        con.print(f"[yellow]-> {hints[status]}[/yellow]")
+
+
 @app.command("rebind")
-def rebind_cmd() -> None:
-    """Request a hardware fingerprint rebind after machine migration."""
+def rebind_cmd(
+    key: Optional[str] = typer.Option(None, "--key", help=_KEY_OPTION_HELP),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt"),
+) -> None:
+    """Move this license's seat onto this machine (after migration/recreate)."""
     con = _console()
-    con.print(
-        "[yellow]This submits a rebind request to the license server. "
-        "Vendor approval is required before a new token is issued.[/yellow]"
-    )
-    typer.confirm("Continue?", abort=True)
-
-    client = _get_client()
-    try:
-        result = _post_with_key_fallback(client, con, "/api/license/rebind")
-    except RavMemAPIError as exc:
-        con.print(f"[red]Rebind request failed: {exc}[/red]")
+    if not yes:
+        con.print("[yellow]This moves the license seat onto this machine's current identity.[/yellow]")
+        typer.confirm("Continue?", abort=True)
+    result = _run_recovery(con, "/api/license/rebind", key, "Rebind failed")
+    if result.get("status") == "rebind_pending":
+        con.print(f"[yellow]{result.get('message')}[/yellow]")
         raise typer.Exit(1)
-    con.print(f"[green]{result.get('message', 'Rebind request submitted.')}[/green]")
+    con.print(f"[green]{result.get('message', 'Rebound.')}[/green]")

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/ravmem/cli/main.py

@@ -1,10 +1,20 @@
 """CLI entry point — registers all subcommands."""
 
 import logging
+import sys
 from typing import Optional
 
 import typer
 
+# Legacy Windows consoles (cp1252) can't encode the ⚠/…/— glyphs used in
+# output; without this, e.g. `ravmem license status` crashed with a
+# UnicodeEncodeError *after* printing, exiting non-zero on a healthy license.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(errors="replace")
+    except Exception:
+        pass
+
 
 def setup_logging(verbose: bool = False) -> None:
     """Configure root logger based on verbosity or RAVMEM_LOG_LEVEL env var.

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/ravmem/client/api.py

@@ -52,6 +52,21 @@ def handle_api_error(exc: Exception) -> None:
     raise typer.Exit(1)
 
 
+_MAX_ATTEMPTS = 8
+_MAX_RETRY_WAIT_SECS = 120
+# A delete waits up to 2 minutes for running jobs to stop, then purges the graph in chunks, which takes minutes on
+# a large project. The normal 30 s timeout would report a failure for a delete that goes on to succeed.
+_DELETE_TIMEOUT_SECS = 1800.0
+
+
+def _retry_after_secs(resp: httpx.Response, attempt: int) -> float:
+    try:
+        wait = float(resp.headers.get("Retry-After", ""))
+    except ValueError:
+        wait = 2 ** attempt
+    return min(max(wait, 1.0), _MAX_RETRY_WAIT_SECS)
+
+
 class RavMemClient:
     """Thin wrapper around the RavMem REST API."""
 
@@ -100,11 +115,25 @@ class RavMemClient:
     # Internal helper
     # ------------------------------------------------------------------
 
-    def _request(self, method: str, path: str, **kwargs) -> dict | list:
-        try:
-            resp = self._client.request(method, path, **kwargs)
-        except (httpx.ConnectError, httpx.TimeoutException):
-            raise
+    def _request(self, method: str, path: str, *, retry_timeouts: bool = False, **kwargs) -> dict | list:
+        """Send a request, waiting out any 429 for as long as the server's Retry-After says.
+
+        ``retry_timeouts`` is only for calls the server treats as idempotent: a timed-out request may still have
+        been processed, so resending anything else could apply it twice.
+        """
+        attempt = 0
+        while True:
+            attempt += 1
+            try:
+                resp = self._client.request(method, path, **kwargs)
+            except httpx.TimeoutException:
+                if not retry_timeouts or attempt >= _MAX_ATTEMPTS:
+                    raise
+                time.sleep(min(2 ** attempt, _MAX_RETRY_WAIT_SECS))
+                continue
+            if resp.status_code != 429 or attempt >= _MAX_ATTEMPTS:
+                break
+            time.sleep(_retry_after_secs(resp, attempt))
 
         try:
             resp.raise_for_status()
@@ -163,7 +192,7 @@ class RavMemClient:
         return self._request("GET", f"/api/projects/{project_id}")
 
     def delete_project(self, project_id: str) -> dict:
-        return self._request("DELETE", f"/api/projects/{project_id}")
+        return self._request("DELETE", f"/api/projects/{project_id}", timeout=_DELETE_TIMEOUT_SECS)
 
     def update_project(self, project_id: str, default_branch: str) -> dict:
         return self._request(
@@ -233,7 +262,8 @@ class RavMemClient:
             body["parent_branch"] = parent_branch
         if langs is not None:
             body["langs"] = langs
-        return self._request("POST", f"/api/projects/{project_id}/index", json=body)
+        # The server ignores a batch it already has, so a timed-out batch is safe to send again.
+        return self._request("POST", f"/api/projects/{project_id}/index", json=body, retry_timeouts=True)
 
     def index_branch(
         self,
@@ -264,7 +294,7 @@ class RavMemClient:
 
     def delete_branch_index(self, project_id: str, branch: str) -> dict:
         return self._request(
-            "DELETE", f"/api/projects/{project_id}/branches/{branch}/index"
+            "DELETE", f"/api/projects/{project_id}/branches/{branch}/index", timeout=_DELETE_TIMEOUT_SECS,
         )
 
     def get_divergence(self, project_id: str, branch: str) -> dict:

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1/ravmem_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.2.0
+Version: 1.3.1
 Summary: RavMem CLI — lightweight client for the RavMem code knowledge graph server
 Author-email: RavMem <harpreet.singh@ravmem.com>
 License-Expression: MIT

{ravmem_cli-1.2.0 → ravmem_cli-1.3.1}/ravmem_cli.egg-info/SOURCES.txt

@@ -33,4 +33,5 @@ ravmem_cli.egg-info/dependency_links.txt
 ravmem_cli.egg-info/entry_points.txt
 ravmem_cli.egg-info/requires.txt
 ravmem_cli.egg-info/top_level.txt
+tests/test_client_delete_timeout.py
 tests/test_smoke.py

ravmem_cli-1.3.1/tests/test_client_delete_timeout.py

@@ -0,0 +1,28 @@
+import httpx
+
+from ravmem.client import api
+
+
+def _client_seeing(seen):
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request.extensions["timeout"])
+        return httpx.Response(200, json={"deleted": True})
+
+    client = api.RavMemClient("http://server")
+    client._client = httpx.Client(base_url="http://server", transport=httpx.MockTransport(handler), timeout=30.0)
+    return client
+
+
+def test_deletes_wait_longer_than_the_default_timeout():
+    seen = []
+    client = _client_seeing(seen)
+    client.delete_project("p")
+    client.delete_branch_index("p", "main")
+    assert [t["read"] for t in seen] == [api._DELETE_TIMEOUT_SECS] * 2
+
+
+def test_other_calls_keep_the_default_timeout():
+    seen = []
+    client = _client_seeing(seen)
+    client._request("GET", "/api/projects")
+    assert seen[0]["read"] == 30.0