ground-control-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: ground-control-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: What runs on a developer's machine: the command line and the agent's plugin.
 Requires-Python: >=3.12

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/cli.py

@@ -252,9 +252,17 @@ def remove() -> int:
     except ServiceError as e:
         say(f"The queue could not all be sent: {e.detail}.")
     if queue.waiting():
-        dropped = queue.drop_all()
-        if dropped:
-            say(f"{dropped} rows of the method log could not be sent, and are dropped.")
+        dropped, untold = queue.drop_all(_service_for)
+        if dropped - untold:
+            say(
+                f"{dropped - untold} rows of the method log could not be sent, and are dropped; "
+                "the service was told which."
+            )
+        if untold:
+            say(
+                f"{untold} rows of the method log could not be sent, and are dropped; the service "
+                "could not be told which, so features they belong to cannot pass their gate."
+            )
     for address in machine.load()["companies"]:
         called = machine.service(address, here)
         if called is not None:

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/probes/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 
-from . import code, deploy, gh, git, health, request, tests, workspace
+from . import code, deploy, gh, git, health, queue, request, tests, workspace
 
 # Every probe the client runs: its name -> the function of (params, root) that runs it.
 RUNS: dict[str, Callable[[dict, object], dict]] = {
@@ -43,6 +43,7 @@ RUNS: dict[str, Callable[[dict, object], dict]] = {
     "workspace.changes": workspace.changes,
     "deploy.commit": deploy.commit,
     "deploy.discover": deploy.discover,
+    "queue.waiting": queue.waiting,
 }
 
 

ground_control_cli-0.5.0/probes/queue.py

@@ -0,0 +1,31 @@
+"""queue.waiting: how many of a feature's rows still wait in this machine's queue.
+
+A count, never a row: the service reads it at the gate, so nothing passes while the machine
+still holds a row of the feature (client/queue.py).
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+from . import errors
+
+
+def waiting(params: dict, root) -> dict:
+    """Count the feature's rows in the machine's queue.
+
+    Args:
+        params: {feature, repo}.
+        root: Not read: the queue is the machine's.
+
+    Returns:
+        {waiting, error}.
+
+    Company: assumes none.
+    """
+    from client import queue  # the queue sends through the service, which runs the probes
+
+    try:
+        return {"waiting": queue.waiting_for(params["feature"], params["repo"]), "error": None}
+    except (sqlite3.Error, OSError):
+        return {"waiting": 0, "error": errors.UNREADABLE}

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/probes/request.py

@@ -4,8 +4,9 @@ Where the company has not connected its GitHub, the service cannot read a reques
 developer's machine reads it: through `gh` when it is installed, else with the developer's own
 token (GH_TOKEN or GITHUB_TOKEN) over GitHub's API. Only facts leave the machine: whether
 `## Description` says anything, how many items `## What needs to be done` lists, the design's
-links and flow, the labels and when each was added, and the feature's name made from the title;
-never the request's words. The service reads the same facts alike (app/method/requests.py).
+links and flow, the labels and when each was added, and its key (the issue's number), which names
+the feature; never the request's words. The service reads the same facts alike
+(app/method/requests.py).
 """
 
 from __future__ import annotations
@@ -25,7 +26,6 @@ GITHUB_WEB = "https://github.com"
 TIMEOUT = 10
 LABELS_MAX = 100
 EVENTS_MAX = 100
-NAME_LENGTH = 40
 TOKENS = ("GH_TOKEN", "GITHUB_TOKEN")
 
 WHAT_HEADING = "description"
@@ -120,12 +120,6 @@ def _mermaid(text: str) -> bool:
     return False
 
 
-def slug(title: str) -> str:
-    """The feature's name from a title: lowercase words joined by `-`, at most 40 characters."""
-    name = re.sub(r"[^a-z0-9]+", "-", (title or "").lower()).strip("-")
-    return name[:NAME_LENGTH].rstrip("-")
-
-
 def labelled_at(events: list) -> list:
     """When each label was last added, from GitHub's LabeledEvent nodes, sorted by name."""
     found: dict = {}
@@ -143,7 +137,7 @@ def _facts(issue: dict) -> dict:
     links = [u.rstrip(URL_END) for u in URL_RE.findall(design or "")]
     return {
         "url": issue["url"],
-        "name": slug(issue.get("title") or ""),
+        "key": str(issue["number"]),
         "labels": [label["name"] for label in issue["labels"]["nodes"]],
         "labelled_at": labelled_at(issue["timelineItems"]["nodes"]),
         "what": bool((section(body, WHAT_HEADING) or "").strip()),

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ground-control-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "What runs on a developer's machine: the command line and the agent's plugin."
 requires-python = ">=3.12"
 dependencies = []

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/queue.py

@@ -21,7 +21,8 @@ A refusal that is not about a row is handled by its cause, never by trying again
 - the machine's key is refused (it was disconnected, its person removed), or the machine holds
   no key for the company: nothing more is sent there, the person is told once, and the rows
   wait until the machine is connected again;
-- the repo is no longer managed: its rows and events are dropped;
+- the repo is no longer managed: its rows and events are dropped, once the service has been told
+  which rows, by id and number, so it holds every number this machine gave;
 - the batch is too large: it is split and sent again;
 - the company is read-only, the client is too old for it, or it refuses otherwise: the rows
   wait, nothing more is sent there until the next session's start, and the person is told once.
@@ -88,8 +89,10 @@ FROM_0 = (
 DISCONNECTED, NO_KEY = "disconnected", "no_key"
 READ_ONLY, TOO_OLD, REFUSED = "read_only", "too_old", "refused"
 UNTIL_CONNECTED = (DISCONNECTED, NO_KEY)
-# The refusal of a batch whose repo the company no longer manages.
+# The refusal of a batch whose repo the company no longer manages; also why its rows are dropped.
 NOT_MANAGED = "not_managed"
+# Why rows are dropped when the client is removed from the machine.
+REMOVED = "removed"
 TOLD = {
     DISCONNECTED: (
         "This machine is disconnected from {address}: {detail} Its method-log rows wait on "
@@ -251,6 +254,26 @@ def write_event(address: str, event: dict) -> dict:
     return found
 
 
+def waiting_for(feature: str, repo: str) -> int:
+    """How many rows of a feature of a repo wait in the queue, whatever their company.
+
+    Args:
+        feature: The feature.
+        repo: The repo, as its host writes it; alike in any case.
+
+    Returns:
+        How many.
+
+    Company: each one the queue holds rows for.
+    """
+    with _db() as db:
+        return db.execute(
+            "select count(*) from rows where lower(repo) = lower(?) "
+            "and json_extract(body, '$.feature') = ?",
+            (repo, feature),
+        ).fetchone()[0]
+
+
 def waiting(address: str | None = None) -> int:
     """How many rows and events wait to be sent, for one company or all."""
     with _db() as db:
@@ -325,25 +348,61 @@ def told() -> list[str]:
     return [TOLD[cause].format(address=address, detail=detail) for address, cause, detail in found]
 
 
-def drop_all() -> int:
-    """Drop everything that waits; how many rows of the method log were dropped.
+def drop_all(service_for: Callable[[str], Service | None]) -> tuple[int, int]:
+    """Drop everything that waits, telling each company first which rows it drops.
+
+    For the client's removal, once it has tried to send them. A row whose company could not be
+    told is dropped all the same; the service then lacks its number.
 
-    For the client's removal, once it has tried to send them.
+    Args:
+        service_for: The service of a company's address, with this machine's key; None when
+            this machine holds no key for it.
+
+    Returns:
+        (how many rows of the method log were dropped, how many of them no company was told of).
 
     Company: each one the queue holds rows for.
     """
     with _db() as db:
         count = db.execute("select count(*) from rows").fetchone()[0]
+        untold = 0
+        for (address,) in db.execute("select distinct address from rows").fetchall():
+            called = service_for(address)
+            try:
+                if called is None:
+                    raise ServiceError(None, NO_KEY)
+                _tell_dropped(db, address, None, called, REMOVED)
+            except ServiceError:
+                untold += db.execute(
+                    "select count(*) from rows where address = ?", (address,)
+                ).fetchone()[0]
         for table in ("rows", "events", "numbers", "stops"):
             db.execute(f"delete from {table}")
-    return count
+    return count, untold
+
+
+def _tell_dropped(db, address: str, repo: str | None, called: Service, why: str) -> None:
+    """Tell the company which of its rows (of one repo, or all) are dropped, a batch at a time.
+
+    Raises:
+        ServiceError: If the service refuses or cannot be reached: nothing is dropped then.
+    """
+    found = db.execute(
+        "select seq, id from rows where address = ? and (? is null or repo = ?) order by seq",
+        (address, repo, repo),
+    ).fetchall()
+    for at in range(0, len(found), BATCH):
+        batch = found[at : at + BATCH]
+        called.send_dropped([{"id": i, "seq": s} for s, i in batch], why)
 
 
 class _Stop(Exception):
     """Sending to this company stops, for its cause; the rest go on."""
 
 
-def _refused(db, address: str, repo: str, e: ServiceError) -> int | None:
+def _refused(
+    db, address: str, repo: str, e: ServiceError, called: Service | None = None
+) -> int | None:
     """Act on a refusal by its cause: the most a batch may hold now, or None when the repo is done.
 
     Raises:
@@ -356,6 +415,15 @@ def _refused(db, address: str, repo: str, e: ServiceError) -> int | None:
         _stop(db, address, DISCONNECTED, e.detail)
         raise _Stop()
     if e.status == 409 and e.refusal == NOT_MANAGED:
+        if called is not None:
+            try:
+                _tell_dropped(db, address, repo, called, NOT_MANAGED)
+            except ServiceError as told:
+                if told.status is None or told.status >= 500:
+                    raise told from None
+                cause = {401: DISCONNECTED, 403: READ_ONLY, 426: TOO_OLD}.get(told.status, REFUSED)
+                _stop(db, address, cause, told.detail)
+                raise _Stop() from None
         db.execute("delete from rows where address = ? and repo = ?", (address, repo))
         db.execute("delete from events where address = ? and repo = ?", (address, repo))
         return None
@@ -369,10 +437,19 @@ def _refused(db, address: str, repo: str, e: ServiceError) -> int | None:
     raise _Stop()
 
 
-def _send(db, table: str, key: str, address: str, repo: str, send: Callable) -> None:
+def _send(
+    db,
+    table: str,
+    key: str,
+    address: str,
+    repo: str,
+    send: Callable,
+    called: Service | None = None,
+) -> None:
     """Send one repo's rows or events, a batch at a time; a batch taken leaves the queue whole.
 
-    A batch too large for the service is sent again in halves, never above its limit.
+    A batch too large for the service is sent again in halves, never above its limit. `called`
+    is told which rows are dropped, when the repo is no longer managed.
     """
     size = BATCH
     while True:
@@ -386,7 +463,7 @@ def _send(db, table: str, key: str, address: str, repo: str, send: Callable) ->
         try:
             send([json.loads(body) for _, body in found])
         except ServiceError as e:
-            limit = _refused(db, address, repo, e)
+            limit = _refused(db, address, repo, e, called)
             if limit is None:
                 return
             size = max(1, min(limit, len(found) // 2))
@@ -462,7 +539,7 @@ def flush(
                 passed.add(address)
                 continue
             try:
-                _send(db, "rows", "seq", address, repo, called.send_rows)
+                _send(db, "rows", "seq", address, repo, called.send_rows, called)
                 _send(db, "events", "n", address, repo, called.send_sessions)
             except _Stop:
                 passed.add(address)

{ground_control_cli-0.4.0 → ground_control_cli-0.5.0}/service.py

@@ -276,6 +276,20 @@ class Service:
         """
         return self.call("POST", "/api/plugin/log", {"rows": rows})
 
+    def send_dropped(self, rows: list[dict], why: str) -> dict:
+        """Say which rows of one repo this machine drops unsent, by id and number: {last_seq}.
+
+        Args:
+            rows: Each {id, seq}.
+            why: `not_managed` or `removed`.
+
+        Raises:
+            ServiceError: If the service refuses or cannot be reached.
+
+        Company: the one at the address.
+        """
+        return self.call("POST", "/api/plugin/log/dropped", {"rows": rows, "why": why})
+
     def send_sessions(self, events: list[dict]) -> None:
         """Send what the machine's sessions did.