chartremotely 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.0
+Version: 0.2.1
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 

chartremotely-0.2.1/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.1/chartremotely/push.py

@@ -0,0 +1,100 @@
+"""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. The operator keeps only the newest,
+encrypted, for an hour.
+
+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 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"})
+
+_state = threading.Condition()
+_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 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_reply(request: str, reply: str) -> None:
+    """Call once a reply has been sent. Schedules a picture if the chart changed."""
+    if changes_chart(request, reply):
+        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()))
+        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 → chartremotely-0.2.1}/chartremotely/relay.py

@@ -134,12 +134,16 @@ 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"])
+            reply = execute(command)
             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)
         if once:
             return

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

@@ -17,7 +17,7 @@ import secrets
 import urllib.parse
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
-from . import config
+from . import config, push
 from .vocab import dispatch
 
 
@@ -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."""
+        reply = dispatch(request)
+        self._reply(200, reply)
+        push.after_reply(request, reply)
 
     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.1}/chartremotely/vocab.py

@@ -16,7 +16,7 @@ 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
 
 ERR = "ERR "
 
@@ -126,15 +126,24 @@ def dispatch(request: str) -> str:
     if verb == "scale":
         return cmd_scale(rest)
     if verb == "read":
-        return cmd_read()
+        return _driving(cmd_read)
     if verb == "snapshot":
-        return cmd_snapshot()
+        return _driving(cmd_snapshot)
     if verb == "set":
         ticker, sep, scale = rest.partition("|")
-        return push.after_change(cmd_set(ticker, scale if sep else ""))
+        return _driving(lambda: cmd_set(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 _driving(lambda: cmd_set(ticker))
+
+
+def _driving(command) -> str:
+    """Run one command that drives the chart, never alongside another."""
+    try:
+        with guilock.driving():
+            return command()
+    except guilock.Busy as exc:
+        return ERR + str(exc)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.0
+Version: 0.2.1
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 

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

@@ -6,6 +6,7 @@ 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.1}/pyproject.toml

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

chartremotely-0.2.1/tests/test_push.py

@@ -0,0 +1,107 @@
+"""The picture pushed after a chart change: only after the reply, one per burst, never in the way."""
+
+import threading
+import time
+
+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)
+
+
+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"}
+
+
+@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.1}/tests/test_relay.py

@@ -141,7 +141,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 +155,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: "Showing PLTR. Good luck.")
+    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: events.append(("picture", c)))
+    relay.run(once=True)
+    assert events == ["result", ("picture", "set 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