chartremotely 0.2.0__tar.gz → 0.2.2__tar.gz

{chartremotely-0.2.0 → chartremotely-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.0
+Version: 0.2.2
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -354,6 +354,18 @@ reports anything still missing.
 To pair by hand instead, run `chartremotely pair` and give the code it prints
 to your MCP client (`chart_pair_agent`), or type it on the site's Profile page.
 
+## Releases
+
+Every merge to `main` that changes `chartremotely/` or `pyproject.toml` is
+published to PyPI on its own, once ruff and the tests pass: the next patch
+after the newest `vX.Y.Z` tag, tagged and given a GitHub Release. To release a
+minor or major version instead, raise `version` in `pyproject.toml` in the PR;
+the merge publishes that number. Pushing a `v*` tag by hand still publishes
+exactly that version.
+
+Nothing on a Mac updates itself. Upgrade an installed agent with
+`uv tool upgrade chartremotely`.
+
 ## How it finds anything
 
 Nothing is anchored to screen coordinates. thinkorswim layouts differ per

{chartremotely-0.2.0 → chartremotely-0.2.2}/README.md

@@ -130,6 +130,18 @@ reports anything still missing.
 To pair by hand instead, run `chartremotely pair` and give the code it prints
 to your MCP client (`chart_pair_agent`), or type it on the site's Profile page.
 
+## Releases
+
+Every merge to `main` that changes `chartremotely/` or `pyproject.toml` is
+published to PyPI on its own, once ruff and the tests pass: the next patch
+after the newest `vX.Y.Z` tag, tagged and given a GitHub Release. To release a
+minor or major version instead, raise `version` in `pyproject.toml` in the PR;
+the merge publishes that number. Pushing a `v*` tag by hand still publishes
+exactly that version.
+
+Nothing on a Mac updates itself. Upgrade an installed agent with
+`uv tool upgrade chartremotely`.
+
 ## How it finds anything
 
 Nothing is anchored to screen coordinates. thinkorswim layouts differ per

chartremotely-0.2.2/chartremotely/answer.py

@@ -0,0 +1,21 @@
+"""What a command answers: the words for the caller, and what it put on the chart.
+
+Stdlib only, so the relay and the push can carry it without importing the
+macOS drivers.
+"""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+
+class Answer(NamedTuple):
+    """A command's reply, plus the symbol it put on the chart when it did.
+
+    ``symbol`` is set only by a successful chart change that named one; the
+    picture of that change is labelled with it, so a label never depends on
+    how the reply happens to be worded.
+    """
+
+    reply: str
+    symbol: str | None = None

chartremotely-0.2.2/chartremotely/guilock.py

@@ -0,0 +1,48 @@
+"""One driver of thinkorswim at a time, across every process on this Mac.
+
+The Siri listener (`serve`) and the website's relay (`relay`) are separate
+processes, and each can drive the chart; so can the background picture taken
+after a change. Two of them hit-testing and typing into the same symbol field
+at once is how a good request comes back as an error. A file lock is the one
+primitive both processes and their threads share.
+
+Stdlib only, so the wire logic that imports it stays importable on Linux.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import time
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+from . import config
+
+LOCK_NAME = "gui.lock"
+#: Longest a request waits for another to finish driving the chart.
+WAIT_SECONDS = 30.0
+_POLL_SECONDS = 0.1
+
+
+class Busy(TimeoutError):
+    """Another request held the chart for longer than WAIT_SECONDS."""
+
+
+@contextmanager
+def driving(wait: float = WAIT_SECONDS) -> Iterator[None]:
+    """Hold the chart for the duration of the block."""
+    config.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(config.CONFIG_DIR / LOCK_NAME, "a") as handle:
+        deadline = time.monotonic() + wait
+        while True:
+            try:
+                fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                break
+            except BlockingIOError:
+                if time.monotonic() >= deadline:
+                    raise Busy("the chart is busy with another request") from None
+                time.sleep(_POLL_SECONDS)
+        try:
+            yield
+        finally:
+            fcntl.flock(handle, fcntl.LOCK_UN)

chartremotely-0.2.2/chartremotely/push.py

@@ -0,0 +1,152 @@
+"""Tell the operator what the chart looks like after it changes.
+
+A chart changed by voice goes straight to this machine over the tailnet, so
+the operator never hears of it. Once a change is answered — after the reply
+("… Good luck.") has been sent — one picture of the chart pane is pushed up so
+the patron's browser can offer it, labelled with the symbol the last command
+of the burst put on the chart (the symbol field is read only as a fallback:
+it can be stale). The operator keeps the newest picture per symbol,
+encrypted, for an hour each.
+
+Three rules keep it out of the way:
+
+* **After the reply.** The listener and the relay schedule the picture only
+  once their reply has gone out, so it never delays or races the answer.
+* **Coalesced.** Changes in quick succession produce one picture, taken when
+  the chart has been quiet for QUIET_SECONDS — never a trail of in-between
+  captures.
+* **Serialised.** The capture holds the same cross-process lock as every
+  command that drives the chart (guilock), so it never overlaps one.
+
+Any failure is swallowed: the chart already changed, and a missing picture
+must never become a spoken error. Stdlib only at module scope, like the relay;
+the capture is imported lazily.
+"""
+
+from __future__ import annotations
+
+import re
+import threading
+import time
+
+from . import config, guilock, relay
+
+#: How long the chart must go unchanged before its picture is taken.
+QUIET_SECONDS = 1.5
+
+#: Verbs that read or picture the chart, or only resolve words: they change
+#: nothing, so no picture follows them. Every other request — `set`, or a bare
+#: company name — changes the chart (see vocab.dispatch).
+_NOT_A_CHANGE = frozenset({"resolve", "scale", "read", "snapshot"})
+
+#: What a symbol label may look like on the wire: tickers, futures (/ES),
+#: indices (.SPX, $SPX.X, ^VIX) and share classes (BRK/B). The operator checks
+#: the same shape; anything else is left off rather than sent.
+SYMBOL = re.compile(r"^[A-Z0-9./^$-]{1,15}$")
+
+_state = threading.Condition()
+#: The symbol the last successful chart-changing command put on the chart.
+#: A burst's picture carries the LAST one; a change that names none keeps it.
+_named: str | None = None
+_due: float | None = None
+_worker: threading.Thread | None = None
+
+
+def changes_chart(request: str, reply: str) -> bool:
+    """Whether this answered request changed what the chart shows."""
+    verb = (request or "").strip().partition(" ")[0].lower()
+    return bool(verb) and verb not in _NOT_A_CHANGE and not reply.startswith("ERR")
+
+
+def symbol_label(raw: object) -> str | None:
+    """The chart's symbol as sent to the operator, or None when it is not symbol-shaped."""
+    if not isinstance(raw, str):
+        return None
+    label = raw.strip().upper()
+    return label if SYMBOL.match(label) else None
+
+
+def payload(cfg: dict, image: str, symbol: str | None = None) -> tuple[str, dict] | None:
+    """Where to send a picture and what to send, or None when not paired.
+
+    ``symbol`` is what the chart showed when the picture was taken; it is left
+    out when unknown or not symbol-shaped, and the operator files the picture
+    under a plain "Chart".
+    """
+    base = (cfg.get("operator_url") or "").rstrip("/")
+    agent_id, secret = cfg.get("agent_id"), cfg.get("agent_secret")
+    if not (base and agent_id and secret):
+        return None
+    body = {"agent_id": agent_id, "secret": secret, "image": image}
+    label = symbol_label(symbol)
+    if label:
+        body["symbol"] = label
+    return f"{base}/agent/snapshot", body
+
+
+def _showing() -> str | None:
+    """The symbol field's value, or None. Never raises.
+
+    Only a fallback: thinkorswim does not push accessibility updates, so right
+    after a change this can still name the previous symbol. The symbol a
+    command named is preferred whenever one is known.
+    """
+    try:
+        from . import symbol
+        return symbol_label(symbol.current())
+    except Exception:  # noqa: BLE001 - a label is optional; the picture is not
+        return None
+
+
+def after_reply(request: str, reply: str, symbol: str | None = None) -> None:
+    """Call once a reply has been sent. Schedules a picture if the chart changed.
+
+    ``symbol`` is what the command put on the chart (vocab.Answer.symbol), when
+    it named one; a change that names none keeps the previous command's.
+    """
+    global _named
+    if changes_chart(request, reply):
+        with _state:
+            _named = symbol_label(symbol) or _named
+        schedule()
+
+
+def schedule() -> None:
+    """Ask for one picture once the chart has been quiet; later asks push it back."""
+    global _due, _worker
+    with _state:
+        _due = time.monotonic() + QUIET_SECONDS
+        if _worker is None or not _worker.is_alive():
+            _worker = threading.Thread(target=_wait_then_push, name="push-latest", daemon=True)
+            _worker.start()
+        _state.notify_all()
+
+
+def _wait_then_push() -> None:
+    global _due
+    with _state:
+        while True:
+            remaining = (_due or 0) - time.monotonic()
+            if remaining <= 0:
+                _due = None
+                break
+            _state.wait(remaining)
+    push_now()
+
+
+def push_now() -> None:
+    """Take the chart's picture and send it. Never raises."""
+    try:
+        cfg = config.load()
+        if payload(cfg, "") is None:
+            return
+        from . import snapshot, window
+        with guilock.driving():
+            image = snapshot.as_reply(snapshot.shrink(window.capture()))
+            with _state:
+                label = _named
+            label = label or _showing()
+        url, body = payload(cfg, image, label)
+        relay._post(url, body, timeout=30)
+    except Exception:  # noqa: BLE001, S110 - deliberate: see the module docstring
+        pass

{chartremotely-0.2.0 → chartremotely-0.2.2}/chartremotely/relay.py

@@ -19,6 +19,7 @@ import urllib.error
 import urllib.request
 
 from . import config
+from .answer import Answer
 
 #: Poll window. The operator holds a request open for slightly less than
 #: this, so a timeout here means the network dropped it, not that the
@@ -32,7 +33,7 @@ class PairingError(RuntimeError):
     """Pairing could not be completed."""
 
 
-def execute(command: str) -> str:
+def execute(command: str) -> Answer:
     """Hand a relayed command to the agent's own vocabulary.
 
     Imported lazily and wrapped here for one reason: the wire logic in this
@@ -40,8 +41,8 @@ def execute(command: str) -> str:
     drivers in with it - making the whole file unimportable anywhere the
     drivers are not installed, CI included.
     """
-    from .vocab import dispatch
-    return dispatch(command)
+    from .vocab import answer
+    return answer(command)
 
 
 def _post(url: str, payload: dict, timeout: float) -> dict:
@@ -134,12 +135,17 @@ def run(operator_url: str | None = None, once: bool = False) -> None:
             continue
 
         if envelope.get("command"):
-            reply = execute(str(envelope["command"]))
+            command = str(envelope["command"])
+            result = execute(command)
+            reply = result.reply
             try:
                 _post(f"{base}/agent/result",
                       {**credentials, "id": envelope.get("id"), "reply": reply},
                       timeout=20)
             except (urllib.error.URLError, TimeoutError, OSError):
                 pass          # the caller has already timed out and refunded
+            # After the reply, never before: the picture of a changed chart.
+            from . import push
+            push.after_reply(command, reply, result.symbol)
         if once:
             return

{chartremotely-0.2.0 → chartremotely-0.2.2}/chartremotely/server.py

@@ -17,8 +17,8 @@ import secrets
 import urllib.parse
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
-from . import config
-from .vocab import dispatch
+from . import config, push
+from .vocab import answer
 
 
 class Handler(BaseHTTPRequestHandler):
@@ -48,7 +48,7 @@ class Handler(BaseHTTPRequestHandler):
                 raw = str(json.loads(raw).get("cmd") or "").strip()
             except ValueError:
                 return self._reply(400, "ERR bad JSON")
-        self._reply(200, dispatch(raw))
+        self._answer(raw)
 
     def do_GET(self) -> None:
         parsed = urllib.parse.urlparse(self.path)
@@ -57,7 +57,13 @@ class Handler(BaseHTTPRequestHandler):
         query = urllib.parse.parse_qs(parsed.query)
         if not self._authorised((query.get("t") or [None])[0]):
             return self._reply(403, "ERR forbidden")
-        self._reply(200, dispatch((query.get("cmd") or [""])[0].strip()))
+        self._answer((query.get("cmd") or [""])[0].strip())
+
+    def _answer(self, request: str) -> None:
+        """Reply first; only then schedule the picture of a changed chart."""
+        result = answer(request)
+        self._reply(200, result.reply)
+        push.after_reply(request, result.reply, result.symbol)
 
     def log_message(self, *args) -> None:
         """Silence. Requests carry spoken input; do not write it to a log."""

{chartremotely-0.2.0 → chartremotely-0.2.2}/chartremotely/vocab.py

@@ -16,7 +16,8 @@ Two rules the callers depend on:
 
 from __future__ import annotations
 
-from . import push, registry, resolve, scales, snapshot, symbol, timeframe, window
+from . import guilock, registry, resolve, scales, snapshot, symbol, timeframe, window
+from .answer import Answer
 
 ERR = "ERR "
 
@@ -48,6 +49,11 @@ def cmd_scale(spoken: str) -> str:
 
 
 def cmd_set(ticker: str, scale: str = "") -> str:
+    """Put a ticker on the chart; see :func:`set_chart`. Returns only the words."""
+    return set_chart(ticker, scale).reply
+
+
+def set_chart(ticker: str, scale: str = "") -> Answer:
     """Put a ticker on the chart, optionally at a given scale.
 
     Degrades deliberately: an unparseable scale leaves the chart alone and
@@ -56,11 +62,12 @@ def cmd_set(ticker: str, scale: str = "") -> str:
     """
     ticker = ticker.strip().replace(" ", "")
     if not ticker:
-        return ERR + "No symbol to show."
+        return Answer(ERR + "No symbol to show.")
     try:
         symbol.show(ticker)
     except Exception as exc:
-        return ERR + _short(exc)
+        return Answer(ERR + _short(exc))
+    shown = symbol.to_ticker(ticker)
 
     word = None
     if scale.strip() and scale.strip().lower() not in scales.AS_IS:
@@ -76,12 +83,12 @@ def cmd_set(ticker: str, scale: str = "") -> str:
         pass
 
     if word:
-        return f"Showing {ticker} at {word}. Good luck."
+        return Answer(f"Showing {ticker} at {word}. Good luck.", shown)
     try:
         _, current = timeframe.current()
-        return f"Showing {ticker} at {current}, as is. Good luck."
+        return Answer(f"Showing {ticker} at {current}, as is. Good luck.", shown)
     except Exception:
-        return f"Showing {ticker}. Good luck."
+        return Answer(f"Showing {ticker}. Good luck.", shown)
 
 
 def cmd_read() -> str:
@@ -103,8 +110,16 @@ def cmd_snapshot() -> str:
 
 
 def dispatch(request: str) -> str:
+    """Route one request and return only its words; see :func:`answer`."""
+    return answer(request).reply
+
+
+def answer(request: str) -> Answer:
     """Route one request. Anything unrecognised is treated as a company name.
 
+    The Answer carries the symbol a successful change put on the chart, so
+    the picture that follows is labelled from data, not from the reply text.
+
     The entire surface:
 
         resolve <spoken name>              -> TICKER | ERR
@@ -116,25 +131,34 @@ def dispatch(request: str) -> str:
     """
     request = (request or "").strip()
     if not request:
-        return ERR + "I didn't catch that."
+        return Answer(ERR + "I didn't catch that.")
 
     verb, _, rest = request.partition(" ")
     verb = verb.lower()
 
     if verb == "resolve":
-        return cmd_resolve(rest)
+        return Answer(cmd_resolve(rest))
     if verb == "scale":
-        return cmd_scale(rest)
+        return Answer(cmd_scale(rest))
     if verb == "read":
-        return cmd_read()
+        return _driving(lambda: Answer(cmd_read()))
     if verb == "snapshot":
-        return cmd_snapshot()
+        return _driving(lambda: Answer(cmd_snapshot()))
     if verb == "set":
         ticker, sep, scale = rest.partition("|")
-        return push.after_change(cmd_set(ticker, scale if sep else ""))
+        return _driving(lambda: set_chart(ticker, scale if sep else ""))
 
     # Bare name: resolve and show it.
     ticker = cmd_resolve(request)
     if ticker.startswith(ERR):
-        return ticker
-    return push.after_change(cmd_set(ticker))
+        return Answer(ticker)
+    return _driving(lambda: set_chart(ticker))
+
+
+def _driving(command) -> Answer:
+    """Run one command that drives the chart, never alongside another."""
+    try:
+        with guilock.driving():
+            return command()
+    except guilock.Busy as exc:
+        return Answer(ERR + str(exc))

{chartremotely-0.2.0 → chartremotely-0.2.2}/chartremotely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.0
+Version: 0.2.2
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -354,6 +354,18 @@ reports anything still missing.
 To pair by hand instead, run `chartremotely pair` and give the code it prints
 to your MCP client (`chart_pair_agent`), or type it on the site's Profile page.
 
+## Releases
+
+Every merge to `main` that changes `chartremotely/` or `pyproject.toml` is
+published to PyPI on its own, once ruff and the tests pass: the next patch
+after the newest `vX.Y.Z` tag, tagged and given a GitHub Release. To release a
+minor or major version instead, raise `version` in `pyproject.toml` in the PR;
+the merge publishes that number. Pushing a `v*` tag by hand still publishes
+exactly that version.
+
+Nothing on a Mac updates itself. Upgrade an installed agent with
+`uv tool upgrade chartremotely`.
+
 ## How it finds anything
 
 Nothing is anchored to screen coordinates. thinkorswim layouts differ per

{chartremotely-0.2.0 → chartremotely-0.2.2}/chartremotely.egg-info/SOURCES.txt

@@ -2,10 +2,12 @@ LICENSE
 README.md
 pyproject.toml
 chartremotely/__init__.py
+chartremotely/answer.py
 chartremotely/ax.py
 chartremotely/cli.py
 chartremotely/config.py
 chartremotely/doctor.py
+chartremotely/guilock.py
 chartremotely/keystore.py
 chartremotely/layout.py
 chartremotely/mcpclient.py

{chartremotely-0.2.0 → chartremotely-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chartremotely"
-version = "0.2.0"
+version = "0.2.2"
 description = "Remote control of desktop charting applications on macOS"
 readme = "README.md"
 requires-python = ">=3.11"

chartremotely-0.2.2/tests/test_push.py

@@ -0,0 +1,188 @@
+"""The picture pushed after a chart change: only after the reply, one per burst, never in the way."""
+
+import threading
+import time
+import types
+
+import pytest
+
+from chartremotely import guilock, push
+
+PAIRED = {"operator_url": "https://op.test/", "agent_id": "a1", "agent_secret": "s1"}
+
+
+@pytest.fixture(autouse=True)
+def isolated_config(tmp_path, monkeypatch):
+    monkeypatch.setattr(guilock.config, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(push, "_named", None)
+
+
+def test_an_unpaired_mac_pushes_nothing():
+    assert push.payload({"operator_url": None, "agent_id": None, "agent_secret": None}, "x") is None
+    assert push.payload({**PAIRED, "agent_secret": ""}, "x") is None
+
+
+def test_the_push_carries_the_agents_identity_and_the_picture():
+    url, body = push.payload(PAIRED, "data:image/jpeg;base64,AAAA")
+    assert url == "https://op.test/agent/snapshot"
+    assert body == {"agent_id": "a1", "secret": "s1", "image": "data:image/jpeg;base64,AAAA"}
+
+
+def test_the_push_names_the_symbol_the_chart_shows():
+    _, body = push.payload(PAIRED, "img", " pltr ")
+    assert body["symbol"] == "PLTR"
+
+
+@pytest.mark.parametrize("raw", ["/ES", ".SPX", "$SPX.X", "^VIX", "BRK/B", "BRK-B", "A"])
+def test_futures_indices_and_share_classes_are_symbol_shaped(raw):
+    assert push.symbol_label(raw) == raw
+
+
+@pytest.mark.parametrize("raw", [None, "", "   ", "TOO-LONG-A-SYMBOL", "PL TR", "<b>", "PLTR;", 7])
+def test_an_unreadable_symbol_is_left_off_rather_than_sent(raw):
+    _, body = push.payload(PAIRED, "img", raw)
+    assert "symbol" not in body
+
+
+@pytest.fixture
+def labelled(monkeypatch):
+    """Capture stubbed out; returns the bodies pushed. The symbol field reads OLD."""
+    import chartremotely
+
+    sent = []
+    monkeypatch.setattr(push.config, "load", lambda: PAIRED)
+    monkeypatch.setattr(push.relay, "_post", lambda url, body, timeout: sent.append(body))
+    monkeypatch.setattr(push, "_showing", lambda: "OLD")
+    monkeypatch.setattr(chartremotely, "window",
+                        types.SimpleNamespace(capture=lambda: b"png"), raising=False)
+    monkeypatch.setattr(chartremotely, "snapshot",
+                        types.SimpleNamespace(shrink=lambda b: b, as_reply=lambda b: "data:img"),
+                        raising=False)
+    return sent
+
+
+def test_a_burst_is_labelled_with_its_last_set(monkeypatch, labelled):
+    monkeypatch.setattr(push, "QUIET_SECONDS", 0.1)
+    push.after_reply("set AAPL", "Showing AAPL at swing, as is. Good luck.", "AAPL")
+    push.after_reply("set MSFT | daily", "Showing MSFT at daily. Good luck.", "MSFT")
+    time.sleep(0.4)
+    assert [b["symbol"] for b in labelled] == ["MSFT"]
+
+
+def test_a_change_naming_no_symbol_keeps_the_last_sets(monkeypatch, labelled):
+    monkeypatch.setattr(push, "schedule", lambda: None)
+    push.after_reply("set NVDA", "Showing NVDA. Good luck.", "NVDA")
+    push.after_reply("set | swing", "Scale is swing.")  # a change that names no symbol
+    push.push_now()
+    assert labelled[-1]["symbol"] == "NVDA"
+
+
+def test_a_failed_set_does_not_relabel(monkeypatch, labelled):
+    monkeypatch.setattr(push, "schedule", lambda: None)
+    push.after_reply("set NVDA", "Showing NVDA. Good luck.", "NVDA")
+    push.after_reply("set ZZZZ", "ERR no symbol field found")
+    push.push_now()
+    assert labelled[-1]["symbol"] == "NVDA"
+
+
+def test_the_label_comes_from_the_command_not_the_wording(monkeypatch, labelled):
+    monkeypatch.setattr(push, "schedule", lambda: None)
+    push.after_reply("set TSLA", "Now on the wall: Tesla. Enjoy.", "TSLA")
+    push.push_now()
+    assert labelled[-1]["symbol"] == "TSLA"
+
+
+def test_the_symbol_field_is_only_the_fallback(labelled):
+    push.push_now()
+    assert labelled[-1]["symbol"] == "OLD"
+
+
+def test_a_failed_symbol_read_still_sends_the_picture(monkeypatch):
+    import chartremotely
+
+    def unreadable():
+        raise RuntimeError("no symbol field")
+    monkeypatch.setattr(chartremotely, "symbol",
+                        types.SimpleNamespace(current=unreadable), raising=False)
+    assert push._showing() is None
+
+
+@pytest.mark.parametrize("request_, reply, changed", [
+    ("set PLTR | swing", "Showing PLTR at swing. Good luck.", True),
+    ("palantir", "Showing PLTR at swing, as is. Good luck.", True),
+    ("set PLTR", "ERR no symbol field found", False),
+    ("resolve palantir", "PLTR", False),
+    ("scale swing", "swing", False),
+    ("read", "PLTR at swing", False),
+    ("snapshot", "data:image/jpeg;base64,AAAA", False),
+    ("", "ERR I didn't catch that.", False),
+])
+def test_only_an_answered_change_earns_a_picture(request_, reply, changed):
+    assert push.changes_chart(request_, reply) is changed
+
+
+def test_a_burst_of_changes_gives_one_picture_after_the_last(monkeypatch):
+    shots = []
+    monkeypatch.setattr(push, "QUIET_SECONDS", 0.15)
+    monkeypatch.setattr(push, "push_now", lambda: shots.append(time.monotonic()))
+    started = time.monotonic()
+    for i in range(4):
+        if i:
+            time.sleep(0.05)
+        push.after_reply("set PLTR", "Showing PLTR. Good luck.")
+        last = time.monotonic()
+    time.sleep(0.5)
+    assert len(shots) == 1, "one picture for the whole burst"
+    assert shots[0] - last >= 0.14, "taken only once the chart went quiet"
+    assert shots[0] > started
+
+
+def test_nothing_is_scheduled_for_a_request_that_changed_nothing(monkeypatch):
+    shots = []
+    monkeypatch.setattr(push, "QUIET_SECONDS", 0.05)
+    monkeypatch.setattr(push, "push_now", lambda: shots.append(1))
+    push.after_reply("resolve palantir", "PLTR")
+    time.sleep(0.2)
+    assert shots == []
+
+
+def test_a_push_never_raises_whatever_goes_wrong(monkeypatch):
+    monkeypatch.setattr(push.config, "load", lambda: PAIRED)
+
+    def boom(*a, **k):
+        raise OSError("operator unreachable")
+    monkeypatch.setattr(push.relay, "_post", boom)
+    push.push_now()  # the capture or the post fails; the chart already changed
+
+
+def test_the_chart_is_driven_by_one_holder_at_a_time():
+    order = []
+
+    def hold(name, pause):
+        with guilock.driving():
+            order.append(f"{name} in")
+            time.sleep(pause)
+            order.append(f"{name} out")
+
+    a = threading.Thread(target=hold, args=("a", 0.2))
+    a.start()
+    time.sleep(0.05)
+    hold("b", 0)
+    a.join()
+    assert order == ["a in", "a out", "b in", "b out"]
+
+
+def test_a_holder_that_never_lets_go_is_reported_busy():
+    release = threading.Event()
+
+    def hog():
+        with guilock.driving():
+            release.wait(2)
+
+    t = threading.Thread(target=hog)
+    t.start()
+    time.sleep(0.05)
+    with pytest.raises(guilock.Busy), guilock.driving(wait=0.2):
+        pass
+    release.set()
+    t.join()

{chartremotely-0.2.0 → chartremotely-0.2.2}/tests/test_relay.py

@@ -12,6 +12,7 @@ from typing import ClassVar
 import pytest
 
 from chartremotely import relay
+from chartremotely.answer import Answer
 
 
 class StubOperator(BaseHTTPRequestHandler):
@@ -100,7 +101,7 @@ def test_a_relayed_command_is_dispatched_and_answered(operator, monkeypatch):
     relay.pair(operator, on_code=lambda c: None)
     StubOperator.commands.append({"id": "r1", "command": "read"})
     # The vocabulary is the agent's own; stub it so no GUI is required.
-    monkeypatch.setattr(relay, "execute", lambda cmd: f"dispatched:{cmd}")
+    monkeypatch.setattr(relay, "execute", lambda cmd: Answer(f"dispatched:{cmd}"))
     relay.run(once=True)
     assert StubOperator.results == [
         {"agent_id": "a1", "secret": "s1", "id": "r1", "reply": "dispatched:read"}]
@@ -109,7 +110,7 @@ def test_a_relayed_command_is_dispatched_and_answered(operator, monkeypatch):
 def test_an_idle_poll_reports_nothing(operator, monkeypatch):
     StubOperator.claimed = True
     relay.pair(operator, on_code=lambda c: None)
-    monkeypatch.setattr(relay, "execute", lambda cmd: "should not be called")
+    monkeypatch.setattr(relay, "execute", lambda cmd: Answer("should not be called"))
     relay.run(once=True)
     assert StubOperator.results == []
 
@@ -141,7 +142,7 @@ def test_the_wire_logic_imports_without_the_macos_drivers():
     from pathlib import Path
 
     forbidden = {"Quartz", "AppKit", "ApplicationServices", "CoreFoundation"}
-    for name in ("relay", "resolve", "scales", "config", "registry", "snapshot", "push",
+    for name in ("relay", "resolve", "scales", "config", "registry", "snapshot", "push", "guilock",
                  "mcpclient", "keystore", "services", "tailnet", "shortcut", "setup"):
         tree = ast.parse(Path(f"chartremotely/{name}.py").read_text())
         for node in ast.walk(tree):
@@ -155,3 +156,23 @@ def test_the_wire_logic_imports_without_the_macos_drivers():
             # are the sanctioned escape hatch.
             if node.col_offset == 0:
                 assert not (names & forbidden), f"{name}.py imports {names & forbidden} at module scope"
+
+
+def test_the_picture_is_scheduled_only_after_the_result_is_posted(operator, monkeypatch):
+    """The reply goes out first; only then may a picture of the changed chart follow."""
+    from chartremotely import push
+    events = []
+    StubOperator.claimed = True
+    relay.pair(operator, on_code=lambda c: None)
+    StubOperator.commands.append({"id": "r2", "command": "set PLTR"})
+    monkeypatch.setattr(relay, "execute", lambda cmd: Answer("Showing PLTR. Good luck.", "PLTR"))
+    real_post = relay._post
+
+    def post(url, payload, timeout):
+        if url.endswith("/agent/result"):
+            events.append("result")
+        return real_post(url, payload, timeout)
+    monkeypatch.setattr(relay, "_post", post)
+    monkeypatch.setattr(push, "after_reply", lambda c, r, s: events.append(("picture", c, s)))
+    relay.run(once=True)
+    assert events == ["result", ("picture", "set PLTR", "PLTR")]

chartremotely-0.2.0/chartremotely/push.py

@@ -1,58 +0,0 @@
-"""Tell the operator what the chart looks like after it changes.
-
-A chart changed by voice goes straight to this machine over the tailnet, so
-the operator never hears of it. Right after a change succeeds, one picture of
-the chart pane is pushed up so the patron's browser can offer it. The operator
-keeps only the newest, encrypted, for an hour.
-
-Off the voice path on purpose: the push runs in the background after the
-answer is already on its way, and any failure is swallowed. The chart has
-already changed; a missing picture must never turn into a spoken error.
-
-Stdlib only at module scope, like the relay: the capture is imported lazily.
-"""
-
-from __future__ import annotations
-
-import threading
-import time
-
-from . import config, relay
-
-#: Time for the chart to redraw before its picture is taken.
-SETTLE_SECONDS = 1.0
-
-_lock = threading.Lock()
-
-
-def payload(cfg: dict, image: str) -> tuple[str, dict] | None:
-    """Where to send a picture and what to send, or None when not paired."""
-    base = (cfg.get("operator_url") or "").rstrip("/")
-    agent_id, secret = cfg.get("agent_id"), cfg.get("agent_secret")
-    if not (base and agent_id and secret):
-        return None
-    return f"{base}/agent/snapshot", {"agent_id": agent_id, "secret": secret, "image": image}
-
-
-def after_change(reply: str) -> str:
-    """Start a picture push if the change worked. Returns the reply unchanged."""
-    if not reply.startswith("ERR"):
-        threading.Thread(target=push_now, name="push-latest", daemon=True).start()
-    return reply
-
-
-def push_now() -> None:
-    """Take the chart's picture and send it. Never raises."""
-    try:
-        cfg = config.load()
-        if payload(cfg, "") is None:
-            return
-        # One at a time: two quick changes should not capture over each other.
-        with _lock:
-            time.sleep(SETTLE_SECONDS)
-            from . import snapshot, window
-            image = snapshot.as_reply(snapshot.shrink(window.capture()))
-            url, body = payload(cfg, image)
-            relay._post(url, body, timeout=30)
-    except Exception:  # noqa: BLE001, S110 - deliberate: see the module docstring
-        pass

chartremotely-0.2.0/tests/test_push.py

@@ -1,47 +0,0 @@
-"""The picture pushed after a chart change: when it goes, and that it never hurts."""
-
-import threading
-
-from chartremotely import push
-
-PAIRED = {"operator_url": "https://op.test/", "agent_id": "a1", "agent_secret": "s1"}
-
-
-def test_an_unpaired_mac_pushes_nothing():
-    assert push.payload({"operator_url": None, "agent_id": None, "agent_secret": None}, "x") is None
-    assert push.payload({**PAIRED, "agent_secret": ""}, "x") is None
-
-
-def test_the_push_carries_the_agents_identity_and_the_picture():
-    url, body = push.payload(PAIRED, "data:image/jpeg;base64,AAAA")
-    assert url == "https://op.test/agent/snapshot"
-    assert body == {"agent_id": "a1", "secret": "s1", "image": "data:image/jpeg;base64,AAAA"}
-
-
-def test_a_failed_change_starts_no_push(monkeypatch):
-    started = []
-    monkeypatch.setattr(threading, "Thread", lambda **kw: started.append(kw) or _Never())
-    assert push.after_change("ERR no match for 'volunteer'") == "ERR no match for 'volunteer'"
-    assert started == []
-
-
-def test_a_good_change_answers_at_once_and_pushes_behind_it(monkeypatch):
-    started = []
-    monkeypatch.setattr(threading, "Thread", lambda **kw: started.append(kw) or _Never())
-    assert push.after_change("Showing PLTR at swing. Good luck.").startswith("Showing PLTR")
-    assert [kw["target"] for kw in started] == [push.push_now]
-
-
-def test_a_push_never_raises_whatever_goes_wrong(monkeypatch):
-    monkeypatch.setattr(push.config, "load", lambda: PAIRED)
-    monkeypatch.setattr(push, "SETTLE_SECONDS", 0)
-
-    def boom(*a, **k):
-        raise OSError("operator unreachable")
-    monkeypatch.setattr(push.relay, "_post", boom)
-    push.push_now()  # the capture or the post fails; the chart already changed
-
-
-class _Never:
-    def start(self):
-        pass