chartremotely 0.2.10__tar.gz → 0.2.11__tar.gz

{chartremotely-0.2.10 → chartremotely-0.2.11}/PKG-INFO

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

chartremotely-0.2.11/chartremotely/popups.py

@@ -0,0 +1,258 @@
+"""Close thinkorswim's popups before anyone looks at the chart.
+
+Two popups get left open over the chart, and a picture taken then shows them:
+
+* the symbol field's autocomplete list (PLTR:XTSE, PLTRX, ...), which hangs
+  under the field after a symbol is typed and often outlives the Return that
+  committed it;
+* the aggregation (time frame) menu, which stays open after a preset is
+  picked or the current one is read.
+
+Neither answers the obvious remedies. An Escape posted to thinkorswim lands on
+whatever holds keyboard focus, which after a commit is nothing at all - so it
+is silently dropped. What works, measured on thinkorswim build 1993:
+
+* the aggregation menu closes when its toggle is pressed again (``AXPress``);
+  the toggle's ``AXValue`` is 1 while the menu shows;
+* the autocomplete list closes on Escape once the symbol field has focus.
+  Escape only hides the list: text typed but not yet committed stays in the
+  field, so it never cancels an entry;
+* focus leaves the field when the chart's own title strip (the line under
+  the field reading "PLTR 10 D 30m") is focused. Setting the field's
+  ``AXFocused`` to false is accepted and ignored.
+
+A Swing field commits its text when it loses focus, so focus is moved off the
+field only when that text is what the chart already shows. Otherwise the field
+keeps focus and its pending text, and nothing changes.
+
+The decisions are pure and live at module scope, over a :class:`Seen`
+snapshot, so they are tested where PyObjC is absent. :func:`dismiss` gathers
+the snapshots and acts; its macOS imports are deferred.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+
+Rect = tuple[float, float, float, float]
+
+#: Longest dismiss() spends closing popups.
+TIMEOUT = 1.5
+#: How often dismiss() looks again after acting.
+POLL = 0.1
+#: Longest dismiss() waits for one action to show before trying it again.
+ACT_WAIT = 0.5
+#: Points of slack when deciding a list hangs from the symbol field.
+SLACK = 8
+#: How far under the field's bottom edge to hit-test for a list or the title.
+PROBE_DY, PROBE_DX = 8, 8
+
+#: The first word of the chart's title strip: the symbol it is drawn for.
+CHART_SYMBOL = re.compile(r"^[./$^]?[A-Z0-9]{1,12}([/.][A-Z0-9]{1,3})?(:[A-Z]+)?$")
+
+CLOSE_SCALE, CLOSE_LIST, LEAVE_FIELD = "close scale menu", "close symbol list", "leave field"
+
+
+@dataclass(frozen=True)
+class Seen:
+    """What the chart's popups and symbol field looked like at one moment."""
+
+    scale_open: bool = False
+    list_open: bool = False
+    field_focused: bool = False
+    field_value: str | None = None
+    #: The chart's title strip, e.g. "PLTR 10 D 30m"; None while a list covers it.
+    title: str | None = None
+
+    @property
+    def clean(self) -> bool:
+        """Nothing is drawn over the chart."""
+        return not (self.scale_open or self.list_open)
+
+
+def hangs_under(field: Rect, table: Rect | None) -> bool:
+    """Whether ``table`` is the autocomplete list dropped from the symbol field.
+
+    thinkorswim paints that list inside the window, so the window server never
+    sees it; the accessibility tree reports it as a table whose top-left corner
+    sits on the field's bottom-left corner. ``field`` is the field's combo box.
+    """
+    if table is None:
+        return False
+    fx, fy, _, fh = field
+    tx, ty, tw, th = table
+    return (tw > 0 and th > 0 and abs(tx - fx) <= SLACK
+            and abs(ty - (fy + fh)) <= SLACK)
+
+
+def chart_symbol(title: str | None) -> str | None:
+    """The symbol a chart title strip names ("PLTR 10 D 30m" -> "PLTR"), or None."""
+    if not isinstance(title, str) or not title.strip():
+        return None
+    word = title.split()[0]
+    return word if CHART_SYMBOL.match(word) else None
+
+
+def shows(title: str | None, entry: str | None) -> bool:
+    """Whether the chart already shows what ``entry`` names.
+
+    A futures root typed as "/ES" is drawn as its front contract ("/ESZ26"),
+    so a root counts as shown by any of its contracts.
+    """
+    drawn = chart_symbol(title)
+    want = (entry or "").strip().upper()
+    if not drawn or not want:
+        return False
+    return drawn == want or (want.startswith("/") and drawn.startswith(want))
+
+
+def next_step(seen: Seen) -> str | None:
+    """The one thing to do next, or None when there is nothing safe left to do.
+
+    The menu is closed before the list: its toggle is pressed through the
+    tree, which needs no focus, whereas closing the list moves focus into the
+    field. Focus leaves the field only when the chart already shows its text,
+    because losing focus commits whatever the field holds.
+    """
+    if seen.scale_open:
+        return CLOSE_SCALE
+    if seen.list_open:
+        return CLOSE_LIST
+    if seen.field_focused and shows(seen.title, seen.field_value):
+        return LEAVE_FIELD
+    return None
+
+
+@dataclass(frozen=True)
+class Dismissed:
+    """What dismiss() did, and whether the chart was left uncovered."""
+
+    did: tuple[str, ...] = ()
+    clean: bool = True
+
+    def __bool__(self) -> bool:
+        return bool(self.did)
+
+    def __str__(self) -> str:
+        done = "; ".join(self.did) or "nothing open"
+        return done if self.clean else done + "; a popup is still open"
+
+
+def run(look: Callable[[], Seen], act: Callable[[str], None], *,
+        until: Callable[[Seen], bool] | None = None, timeout: float = TIMEOUT,
+        clock: Callable[[], float] = time.monotonic,
+        sleep: Callable[[float], None] = time.sleep) -> Dismissed:
+    """Look, act on the next step, and look again until nothing is left.
+
+    ``until``, when given, must also hold before it stops early: a symbol just
+    committed is waited for until the chart's title names it, so focus can
+    leave the field once it is safe to. One action is retried only after it
+    has had ACT_WAIT to show, so a slow repaint is not answered with a second
+    press of a toggle.
+    """
+    deadline = clock() + timeout
+    did: list[str] = []
+    last: tuple[str | None, float] = (None, -ACT_WAIT)
+    while True:
+        seen = look()
+        step = next_step(seen)
+        now = clock()
+        if step is None and (until is None or until(seen)) or now >= deadline:
+            return Dismissed(tuple(did), seen.clean)
+        if step is not None and (step != last[0] or now - last[1] >= ACT_WAIT):
+            act(step)
+            if step not in did:
+                did.append(step)
+            last = (step, now)
+        sleep(POLL)
+
+
+# --------------------------------------------------------------------------
+# macOS. Imported lazily so the decisions above stay importable anywhere.
+
+
+def _frame(ax, element) -> Rect | None:
+    p, s = ax.position(element), ax.size(element)
+    return (p.x, p.y, s.width, s.height) if p and s else None
+
+
+def _under_field(ax, ax_app, field):
+    """The combo's frame, the element just under it, and the list that is, if any."""
+    combo = ax.attr(field, "AXParent")
+    frame = _frame(ax, combo) if combo is not None else None
+    if frame is None:
+        return None, None, None
+    x, y, _, h = frame
+    hit = ax.element_at(ax_app, x + PROBE_DX, y + h + PROBE_DY)
+    table = None
+    for element in (hit, ax.attr(hit, "AXParent") if hit is not None else None):
+        if element is not None and ax.attr(element, "AXRole") == "AXTable":
+            table = element
+            break
+    return frame, hit, table
+
+
+def dismiss(app=None, expect: str | None = None, timeout: float = TIMEOUT) -> Dismissed:
+    """Close the symbol list and the scale menu, and take focus off the field.
+
+    ``expect`` is a symbol just committed: dismiss() then also waits, within
+    ``timeout``, for the chart's title to name it before it lets focus go.
+
+    Idempotent, and cheap when nothing is open: a few accessibility reads.
+    Call it with thinkorswim in front (hit-testing answers from the menu bar
+    otherwise), inside the chart lock, after the change it tidies up after.
+    A field or toggle that cannot be found is left alone rather than raised
+    about: tidying up must never turn a change that landed into an error.
+    """
+    from . import ax, config, symbol, timeframe
+
+    app = app or ax.running_app()
+    pid = app.processIdentifier()
+    ax_app = ax.handle(app)
+    cfg = config.load()
+    try:
+        field, _ = symbol.locate(ax_app, cfg)
+    except symbol.NotFound:
+        field = None
+    try:
+        toggle, _ = timeframe._control(ax_app, cfg)
+    except timeframe.MenuError:
+        toggle = None
+    title = [None]
+
+    def look() -> Seen:
+        scale_open = toggle is not None and ax.attr(toggle, "AXValue") not in (0, "0", False, None)
+        if field is None:
+            return Seen(scale_open=scale_open)
+        frame, hit, table = _under_field(ax, ax_app, field)
+        list_open = frame is not None and hangs_under(
+            frame, _frame(ax, table) if table is not None else None)
+        title[0] = None if list_open else hit
+        return Seen(
+            scale_open=scale_open,
+            list_open=list_open,
+            field_focused=bool(ax.attr(field, "AXFocused")),
+            field_value=ax.attr(field, "AXValue"),
+            title=ax.attr(title[0], "AXValue") if title[0] is not None else None,
+        )
+
+    def act(step: str) -> None:
+        if step == CLOSE_SCALE:
+            ax.perform(toggle, "AXPress")
+        elif step == CLOSE_LIST:
+            # Escape reaches only the focused component; after a commit that
+            # is nothing, so the field is focused first.
+            if not ax.attr(field, "AXFocused"):
+                ax.set_attr(field, "AXFocused", True)
+                time.sleep(0.1)
+            ax.escape(pid)
+        elif step == LEAVE_FIELD:
+            # LEAVE_FIELD is only chosen when the element under the field
+            # read as the chart's title, so title[0] is that strip.
+            ax.set_attr(title[0], "AXFocused", True)
+
+    until = (lambda seen: shows(seen.title, expect)) if expect else None
+    return run(look, act, until=until, timeout=timeout)

{chartremotely-0.2.10 → chartremotely-0.2.11}/chartremotely/symbol.py

@@ -13,11 +13,15 @@ import time
 
 import Quartz
 
-from . import ax, config, layout
+from . import ax, config, layout, popups
 
 # Accepts tickers, futures (/ES), indices (.SPX) and share classes (BRK/B).
 TICKER = re.compile(r"^[./$]?[A-Z]{1,6}([/.][A-Z]{1,2})?(:[A-Z]+)?$")
 
+#: Longest show() waits for the chart's title to name the new symbol.
+COMMIT_WAIT = 3.0
+
+
 class NotFound(RuntimeError):
     """The symbol field could not be located or did not validate."""
 
@@ -157,4 +161,10 @@ def show(ticker: str, app=None) -> str:
     ax.key(ax.KEY_RETURN, 0, pid)
     time.sleep(0.25)
     ax.key(ax.KEY_RETURN, 0, pid)
+
+    # The list can outlive both Returns and would sit over the chart - and
+    # over the chart's title, the one place that says the symbol took. Close
+    # it (Escape never discards a typed entry), wait for the title to name the
+    # ticker, then take focus off the field so nothing is left hanging.
+    popups.dismiss(app, expect=ticker, timeout=COMMIT_WAIT)
     return previous

{chartremotely-0.2.10 → chartremotely-0.2.11}/chartremotely/timeframe.py

@@ -7,6 +7,8 @@ which is the most awkward control in the application:
 * it ignores process-targeted mouse events entirely - no hover, no click
 * arrow keys do not move its selection
 * it dismisses when window activation changes
+* Escape does not close it (keyboard focus is elsewhere); pressing its
+  toggle again does - see :mod:`popups`
 
 Only a real HID click works, which means the target must be uncovered
 *before* the popup opens. Clearing occluders afterwards dismisses it.
@@ -21,7 +23,7 @@ from __future__ import annotations
 import re
 import time
 
-from . import ax, config, layout
+from . import ax, config, layout, popups
 from .scales import AS_IS, MNEMONIC, canon, to_code
 
 ITEM = re.compile(r"^\s*\d+\s*[DYW]\s*:\s*\S+", re.IGNORECASE)
@@ -138,7 +140,7 @@ def presets(app=None) -> list[str]:
     ax_app = ax.handle(app)
     _open(ax_app, config.load())
     rows = _rows(ax_app)
-    ax.escape(app.processIdentifier())
+    popups.dismiss(app)
     return [r["label"] for r in rows]
 
 
@@ -149,7 +151,7 @@ def current(app=None) -> tuple[str, str]:
     ax_app = ax.handle(app)
     _open(ax_app, config.load())
     rows = _rows(ax_app)
-    ax.escape(app.processIdentifier())
+    popups.dismiss(app)
     active = next((r for r in rows if r["active"]), None)
     if active is None:
         raise MenuError("could not read the current scale")
@@ -202,9 +204,8 @@ def set_scale(phrase: str, app=None) -> tuple[str, str]:
         ax.click(match["x"], match["y"], pid)
         time.sleep(0.5)
         label = match["label"]
-        return label, MNEMONIC.get(canon(label), label)
-    except Exception:
-        ax.escape(pid)
-        raise
     finally:
+        # Picked or refused, the menu must not stay over the chart.
+        popups.dismiss(app)
         ax.unhide_apps(hidden)
+    return label, MNEMONIC.get(canon(label), label)

{chartremotely-0.2.10 → chartremotely-0.2.11}/chartremotely/window.py

@@ -16,7 +16,7 @@ from pathlib import Path
 
 import Quartz
 
-from . import ax, config, layout, screen, snapshot, symbol
+from . import ax, config, layout, popups, screen, snapshot, symbol
 
 #: NSApplicationActivateAllWindows | NSApplicationActivateIgnoringOtherApps:
 #: bring every thinkorswim window forward, even when another app is in front.
@@ -112,6 +112,8 @@ def _uncover(pid: int, bounds: dict) -> tuple[str, ...]:
 def capture(app=None) -> bytes:
     """PNG of the chart's own pane, and nothing else in the window.
 
+    Any popup left over the chart is closed first; see :func:`popups.dismiss`.
+
     Captured by window id rather than screen region, so it works even when
     something is floating on top - which is what makes it usable as proof
     that a remote command landed. Then cropped to the pane that holds the
@@ -127,6 +129,8 @@ def capture(app=None) -> bytes:
 
     # Hit-testing answers from the menu bar unless the app is in front.
     ax.activate(app)
+    # Never photograph a symbol list or scale menu left over the chart.
+    popups.dismiss(app)
     ax_app = ax.handle(app)
     prefix = config.load()["window_prefix"]
     hit = symbol.discover(ax_app, prefix)

{chartremotely-0.2.10 → chartremotely-0.2.11}/chartremotely.egg-info/PKG-INFO

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

{chartremotely-0.2.10 → chartremotely-0.2.11}/chartremotely.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ chartremotely/keystore.py
 chartremotely/layout.py
 chartremotely/mcpclient.py
 chartremotely/patron.py
+chartremotely/popups.py
 chartremotely/push.py
 chartremotely/registry.py
 chartremotely/relay.py
@@ -38,6 +39,7 @@ chartremotely.egg-info/requires.txt
 chartremotely.egg-info/top_level.txt
 chartremotely/assets/shortcut-template.plist
 tests/test_patron.py
+tests/test_popups.py
 tests/test_push.py
 tests/test_relay.py
 tests/test_requestlog.py

{chartremotely-0.2.10 → chartremotely-0.2.11}/pyproject.toml

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

chartremotely-0.2.11/tests/test_popups.py

@@ -0,0 +1,132 @@
+"""The pure half of closing thinkorswim's popups: what is open, and what to do next."""
+
+from chartremotely import popups
+from chartremotely.popups import CLOSE_LIST, CLOSE_SCALE, LEAVE_FIELD, Seen
+
+# The symbol combo and the list thinkorswim hung under it, as measured live.
+COMBO = (373, 119, 126, 25)
+LIST = (375, 142, 511, 190)
+
+
+def test_a_table_on_the_fields_bottom_left_corner_is_its_list():
+    assert popups.hangs_under(COMBO, LIST)
+
+
+def test_other_tables_are_not_the_list():
+    assert not popups.hangs_under(COMBO, None)
+    assert not popups.hangs_under(COMBO, (3, 662, 340, 1900))    # the watchlist
+    assert not popups.hangs_under(COMBO, (375, 300, 511, 190))   # lower in the pane
+    assert not popups.hangs_under(COMBO, (375, 142, 0, 0))       # collapsed, not drawn
+
+
+def test_the_charts_title_names_its_symbol():
+    assert popups.chart_symbol("PLTR 10 D 30m") == "PLTR"
+    assert popups.chart_symbol("/ESZ26 5 D 5m") == "/ESZ26"
+    assert popups.chart_symbol("BRK/B 1 Y 1D") == "BRK/B"
+    assert popups.chart_symbol("Lo: 166.03") is None
+    assert popups.chart_symbol("") is None
+    assert popups.chart_symbol(None) is None
+
+
+def test_the_chart_shows_an_entry_only_when_its_title_names_it():
+    assert popups.shows("PLTR 10 D 30m", "pltr ")
+    assert not popups.shows("PLTR 10 D 30m", "PLT")
+    assert popups.shows("/ESZ26 5 D 5m", "/ES")      # a futures root, drawn as its contract
+    assert not popups.shows("ESTC 5 D 5m", "ES")     # but not a mere prefix
+    assert not popups.shows(None, "PLTR")
+    assert not popups.shows("PLTR 10 D 30m", None)
+
+
+def test_nothing_open_and_nothing_focused_needs_nothing():
+    assert popups.next_step(Seen(title="PLTR 10 D 30m", field_value="PLTR")) is None
+    assert Seen().clean
+
+
+def test_the_menu_is_closed_before_the_list():
+    both = Seen(scale_open=True, list_open=True, field_value="PLTR")
+    assert not both.clean
+    assert popups.next_step(both) == CLOSE_SCALE
+    assert popups.next_step(Seen(list_open=True, field_value="PLTR")) == CLOSE_LIST
+
+
+def test_focus_leaves_the_field_only_when_the_chart_shows_its_text():
+    committed = Seen(field_focused=True, field_value="PLTR", title="PLTR 10 D 30m")
+    assert popups.next_step(committed) == LEAVE_FIELD
+    # Losing focus commits the field: a pending "PLT" must keep focus.
+    pending = Seen(field_focused=True, field_value="PLT", title="PLTR 10 D 30m")
+    assert popups.next_step(pending) is None
+    # A title that has not caught up yet is not proof either.
+    behind = Seen(field_focused=True, field_value="NVDA", title="PLTR 10 D 30m")
+    assert popups.next_step(behind) is None
+
+
+class Chart:
+    """A fake thinkorswim: popups that close when acted on, and a clock."""
+
+    def __init__(self, seen: Seen, title_after: float = 0.0, *, stuck: bool = False):
+        self.seen, self.title_after, self.stuck = seen, title_after, stuck
+        self.now, self.acts = 0.0, []
+
+    def clock(self):
+        return self.now
+
+    def sleep(self, seconds):
+        self.now += seconds
+
+    def look(self):
+        title = self.seen.title if self.now >= self.title_after else "OLD 1 D 1m"
+        return Seen(self.seen.scale_open, self.seen.list_open, self.seen.field_focused,
+                    self.seen.field_value, None if self.seen.list_open else title)
+
+    def act(self, step):
+        self.acts.append(step)
+        if self.stuck:
+            return
+        s = self.seen
+        if step == CLOSE_SCALE:
+            self.seen = Seen(False, s.list_open, s.field_focused, s.field_value, s.title)
+        elif step == CLOSE_LIST:
+            self.seen = Seen(s.scale_open, False, True, s.field_value, s.title)
+        elif step == LEAVE_FIELD:
+            self.seen = Seen(s.scale_open, s.list_open, False, s.field_value, s.title)
+
+    def run(self, **kw):
+        return popups.run(self.look, self.act, clock=self.clock, sleep=self.sleep, **kw)
+
+
+def test_run_closes_menu_then_list_then_lets_go_of_the_field():
+    chart = Chart(Seen(True, True, False, "PLTR", "PLTR 10 D 30m"))
+    done = chart.run()
+    assert chart.acts == [CLOSE_SCALE, CLOSE_LIST, LEAVE_FIELD]
+    assert done.clean and done.did == (CLOSE_SCALE, CLOSE_LIST, LEAVE_FIELD)
+
+
+def test_run_is_cheap_and_silent_when_nothing_is_open():
+    chart = Chart(Seen(field_value="PLTR", title="PLTR 10 D 30m"))
+    done = chart.run()
+    assert chart.acts == [] and chart.now == 0
+    assert done.clean and not done and str(done) == "nothing open"
+
+
+def test_run_leaves_a_pending_entry_in_the_field():
+    chart = Chart(Seen(list_open=True, field_value="PLT", title="PLTR 10 D 30m"))
+    done = chart.run()
+    assert chart.acts == [CLOSE_LIST]
+    assert done.clean and chart.seen.field_focused
+
+
+def test_run_waits_for_the_title_to_name_the_new_symbol_before_letting_go():
+    chart = Chart(Seen(list_open=True, field_value="NVDA", title="NVDA 10 D 30m"),
+                  title_after=0.8)
+    done = chart.run(until=lambda seen: popups.shows(seen.title, "NVDA"), timeout=3.0)
+    assert chart.acts == [CLOSE_LIST, LEAVE_FIELD]
+    assert 0.8 <= chart.now < 3.0 and done.clean
+
+
+def test_run_gives_up_at_the_deadline_and_says_so():
+    chart = Chart(Seen(scale_open=True, field_value="PLTR"), stuck=True)
+    done = chart.run(timeout=1.5)
+    assert not done.clean and chart.now >= 1.5
+    # A toggle is pressed again only after it has had time to show.
+    assert 2 <= len(chart.acts) <= 1.5 / popups.ACT_WAIT + 1
+    assert str(done).endswith("a popup is still open")