chartremotely 0.2.1__tar.gz → 0.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.1
+Version: 0.2.3
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -207,7 +207,7 @@ License:
            limitations under the License.
         
 Keywords: thinkorswim,accessibility,automation,charting
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: macos
@@ -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.1 → chartremotely-0.2.3}/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.3/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.1 → chartremotely-0.2.3}/chartremotely/push.py

@@ -3,8 +3,10 @@
 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.
+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:
 
@@ -23,6 +25,7 @@ the capture is imported lazily.
 
 from __future__ import annotations
 
+import re
 import threading
 import time
 
@@ -36,7 +39,15 @@ QUIET_SECONDS = 1.5
 #: 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
 
@@ -47,18 +58,56 @@ def changes_chart(request: str, reply: str) -> bool:
     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."""
+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
-    return f"{base}/agent/snapshot", {"agent_id": agent_id, "secret": secret, "image": image}
+    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.
 
-def after_reply(request: str, reply: str) -> 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()
 
 
@@ -94,7 +143,10 @@ def push_now() -> None:
         from . import snapshot, window
         with guilock.driving():
             image = snapshot.as_reply(snapshot.shrink(window.capture()))
-        url, body = payload(cfg, image)
+            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.1 → chartremotely-0.2.3}/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:
@@ -135,7 +136,8 @@ def run(operator_url: str | None = None, once: bool = False) -> None:
 
         if envelope.get("command"):
             command = str(envelope["command"])
-            reply = execute(command)
+            result = execute(command)
+            reply = result.reply
             try:
                 _post(f"{base}/agent/result",
                       {**credentials, "id": envelope.get("id"), "reply": reply},
@@ -144,6 +146,6 @@ def run(operator_url: str | None = None, once: bool = False) -> None:
                 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)
+            push.after_reply(command, reply, result.symbol)
         if once:
             return

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

@@ -18,7 +18,7 @@ import urllib.parse
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
 from . import config, push
-from .vocab import dispatch
+from .vocab import answer
 
 
 class Handler(BaseHTTPRequestHandler):
@@ -61,9 +61,9 @@ class Handler(BaseHTTPRequestHandler):
 
     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)
+        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.1 → chartremotely-0.2.3}/chartremotely/vocab.py

@@ -17,6 +17,7 @@ Two rules the callers depend on:
 from __future__ import annotations
 
 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,34 +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 _driving(cmd_read)
+        return _driving(lambda: Answer(cmd_read()))
     if verb == "snapshot":
-        return _driving(cmd_snapshot)
+        return _driving(lambda: Answer(cmd_snapshot()))
     if verb == "set":
         ticker, sep, scale = rest.partition("|")
-        return _driving(lambda: 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 _driving(lambda: cmd_set(ticker))
+        return Answer(ticker)
+    return _driving(lambda: set_chart(ticker))
 
 
-def _driving(command) -> str:
+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 ERR + str(exc)
+        return Answer(ERR + str(exc))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.1
+Version: 0.2.3
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -207,7 +207,7 @@ License:
            limitations under the License.
         
 Keywords: thinkorswim,accessibility,automation,charting
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: macos
@@ -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.1 → chartremotely-0.2.3}/chartremotely.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 chartremotely/__init__.py
+chartremotely/answer.py
 chartremotely/ax.py
 chartremotely/cli.py
 chartremotely/config.py

{chartremotely-0.2.1 → chartremotely-0.2.3}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "chartremotely"
-version = "0.2.1"
+version = "0.2.3"
 description = "Remote control of desktop charting applications on macOS"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 license = { file = "LICENSE" }
 authors = [{ name = "Lonnie VanZandt" }]
 keywords = ["thinkorswim", "accessibility", "automation", "charting"]

{chartremotely-0.2.1 → chartremotely-0.2.3}/tests/test_push.py

@@ -2,6 +2,7 @@
 
 import threading
 import time
+import types
 
 import pytest
 
@@ -13,6 +14,7 @@ PAIRED = {"operator_url": "https://op.test/", "agent_id": "a1", "agent_secret":
 @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():
@@ -26,6 +28,85 @@ def test_the_push_carries_the_agents_identity_and_the_picture():
     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),

{chartremotely-0.2.1 → chartremotely-0.2.3}/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 == []
 
@@ -164,7 +165,7 @@ def test_the_picture_is_scheduled_only_after_the_result_is_posted(operator, monk
     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.")
+    monkeypatch.setattr(relay, "execute", lambda cmd: Answer("Showing PLTR. Good luck.", "PLTR"))
     real_post = relay._post
 
     def post(url, payload, timeout):
@@ -172,6 +173,6 @@ def test_the_picture_is_scheduled_only_after_the_result_is_posted(operator, monk
             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)))
+    monkeypatch.setattr(push, "after_reply", lambda c, r, s: events.append(("picture", c, s)))
     relay.run(once=True)
-    assert events == ["result", ("picture", "set PLTR")]
+    assert events == ["result", ("picture", "set PLTR", "PLTR")]