chartremotely 0.2.9__tar.gz → 0.2.10__tar.gz

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

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

{chartremotely-0.2.9 → chartremotely-0.2.10}/chartremotely/ax.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 import time
 
 import Quartz
-from AppKit import NSWorkspace
+from AppKit import NSRunningApplication, NSWorkspace
 from ApplicationServices import (
     AXUIElementCopyActionNames,
     AXUIElementCopyAttributeValue,
@@ -57,11 +57,25 @@ class NotRunning(RuntimeError):
     """thinkorswim is not running."""
 
 
+def app_for(pid: int):
+    """The running application with ``pid``, looked up now; None if gone.
+
+    Never from ``NSWorkspace.runningApplications()``: that list only
+    refreshes on a run loop, which the listener and relay never spin, so an
+    app launched (or quit) after they started is missing from it (or lingers).
+    """
+    return NSRunningApplication.runningApplicationWithProcessIdentifier_(pid)
+
+
 def running_app():
-    for a in NSWorkspace.sharedWorkspace().runningApplications():
-        if APP_NAME.lower() in (a.localizedName() or "").lower():
-            return a
-    raise NotRunning(f"{APP_NAME} is not running")
+    """thinkorswim, found through the window server's live list of windows."""
+    for w in Quartz.CGWindowListCopyWindowInfo(
+            Quartz.kCGWindowListOptionAll, Quartz.kCGNullWindowID) or []:
+        if APP_NAME.lower() in (w.get("kCGWindowOwnerName") or "").lower():
+            app = app_for(w["kCGWindowOwnerPID"])
+            if app is not None:
+                return app
+    raise NotRunning(f"{APP_NAME} is not open on this Mac")
 
 
 def handle(app=None):

{chartremotely-0.2.9 → chartremotely-0.2.10}/chartremotely/requestlog.py

@@ -51,3 +51,12 @@ def outcome(source: str, tool: str, where: str, error: str | None) -> None:
         print(" ".join(parts), file=sys.stderr, flush=True)
     except (OSError, ValueError):
         pass
+
+
+def note(source: str, text: str) -> None:
+    """One free-form line, e.g. what it took to bring the chart in front. Never raises."""
+    try:
+        print(f"{time.strftime('%Y-%m-%dT%H:%M:%S%z')} {source} {_clean(text, ERR_MAX)}",
+              file=sys.stderr, flush=True)
+    except (OSError, ValueError):
+        pass

chartremotely-0.2.10/chartremotely/screen.py

@@ -0,0 +1,116 @@
+"""Decisions about what is on screen, made from a snapshot of the window list.
+
+Getting the chart in front of someone takes macOS calls - unhide, activate,
+un-minimise, raise, hide what covers it - but deciding WHICH window is the
+chart, WHETHER it is on screen yet and WHAT covers it needs none of them. That
+half lives here, over plain dicts shaped like Quartz's window list, so it runs
+(and is tested) where PyObjC is absent. :mod:`window` feeds it.
+
+A window is a dict with ``kCGWindowOwnerPID``, ``kCGWindowLayer`` and
+``kCGWindowBounds`` (``X``, ``Y``, ``Width``, ``Height``), as
+``CGWindowListCopyWindowInfo`` reports it: front to back, on-screen only.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+
+Frame = tuple[float, float, float, float]
+
+#: Points of slack when matching the accessibility frame to the window list.
+TOLERANCE = 2.0
+
+
+def overlaps(a: dict, b: dict) -> bool:
+    """Whether two bounds dicts share any area."""
+    return not (a.get("X", 0) + a.get("Width", 0) <= b.get("X", 0)
+                or a.get("X", 0) >= b.get("X", 0) + b.get("Width", 0)
+                or a.get("Y", 0) + a.get("Height", 0) <= b.get("Y", 0)
+                or a.get("Y", 0) >= b.get("Y", 0) + b.get("Height", 0))
+
+
+def largest(windows: Iterable[dict], pid: int) -> dict | None:
+    """The largest window ``pid`` has on screen."""
+    best, best_area = None, -1.0
+    for w in windows:
+        if w.get("kCGWindowOwnerPID") != pid:
+            continue
+        b = w.get("kCGWindowBounds") or {}
+        area = b.get("Width", 0) * b.get("Height", 0)
+        if area > best_area:
+            best, best_area = w, area
+    return best
+
+
+def showing(windows: Iterable[dict], pid: int, frame: Frame) -> dict | None:
+    """The on-screen window of ``pid`` whose bounds are ``frame``, or None.
+
+    ``frame`` is the chart window's (x, y, w, h) as the accessibility tree
+    reports it. Matching on it, rather than taking the app's largest window,
+    means a detached thinkorswim window left on screen does not count as the
+    chart being back.
+    """
+    for w in windows:
+        if w.get("kCGWindowOwnerPID") != pid:
+            continue
+        b = w.get("kCGWindowBounds") or {}
+        got = (b.get("X", 0), b.get("Y", 0), b.get("Width", 0), b.get("Height", 0))
+        if all(abs(g - f) <= TOLERANCE for g, f in zip(got, frame, strict=True)):
+            return w
+    return None
+
+
+def covering(windows: Iterable[dict], bounds: dict, pid: int,
+             regular: Iterable[int]) -> list[int]:
+    """Pids of ordinary apps with a window overlapping ``bounds``.
+
+    Only ``regular`` apps count: system overlays keep permanent full-screen
+    windows that are neither hideable nor actually in the way. Negative
+    layers are desktop furniture, never in front of the chart.
+    """
+    allowed = set(regular) - {pid}
+    found = [w["kCGWindowOwnerPID"] for w in windows
+             if w.get("kCGWindowOwnerPID") in allowed
+             and w.get("kCGWindowLayer", 0) >= 0
+             and overlaps(w.get("kCGWindowBounds") or {}, bounds)]
+    return list(dict.fromkeys(found))
+
+
+def wait_for(probe: Callable[[], object], timeout: float = 2.0, interval: float = 0.1,
+             clock: Callable[[], float] = time.monotonic,
+             sleep: Callable[[float], None] = time.sleep):
+    """Poll ``probe`` until it returns something truthy, for at most ``timeout`` seconds.
+
+    Returns that value, or None when time ran out. Always probes at least once.
+    """
+    deadline = clock() + timeout
+    while True:
+        found = probe()
+        if found:
+            return found
+        if clock() >= deadline:
+            return None
+        sleep(interval)
+
+
+@dataclass(frozen=True)
+class Presented:
+    """What it took to get the chart in front of the viewer."""
+
+    unhid: bool = False
+    unminimized: bool = False
+    raised: bool = False
+    hid: tuple[str, ...] = ()
+
+    def __bool__(self) -> bool:
+        return self.unhid or self.unminimized or self.raised or bool(self.hid)
+
+    def __str__(self) -> str:
+        done = [word for word, did in (("unhid", self.unhid),
+                                       ("unminimized", self.unminimized),
+                                       ("raised", self.raised)) if did]
+        if self.hid:
+            done.append("hid " + ", ".join(self.hid))
+        return "; ".join(done) or "already in front"

{chartremotely-0.2.9 → chartremotely-0.2.10}/chartremotely/vocab.py

@@ -16,7 +16,7 @@ Two rules the callers depend on:
 
 from __future__ import annotations
 
-from . import guilock, registry, resolve, scales, snapshot, symbol, timeframe, window
+from . import guilock, registry, requestlog, resolve, scales, snapshot, symbol, timeframe, window
 from .answer import Answer
 
 ERR = "ERR "
@@ -26,6 +26,21 @@ def _short(text: str, limit: int = 120) -> str:
     return str(text).splitlines()[0][:limit] if text else "something went wrong"
 
 
+def _present() -> str | None:
+    """Get the chart in front of the viewer before driving it; see window.present.
+
+    Returns an ERR reply when it cannot be, else None. What it took (unhid,
+    raised, which apps it hid) goes to the log, never into the spoken reply.
+    """
+    try:
+        done = window.present()
+    except Exception as exc:
+        return ERR + _short(exc)
+    if done:
+        requestlog.note("present", str(done))
+    return None
+
+
 def cmd_resolve(spoken: str) -> str:
     """A spoken company name, to a ticker."""
     if not spoken.strip():
@@ -63,6 +78,9 @@ def set_chart(ticker: str, scale: str = "") -> Answer:
     ticker = ticker.strip().replace(" ", "")
     if not ticker:
         return Answer(ERR + "No symbol to show.")
+    refused = _present()
+    if refused:
+        return Answer(refused)
     try:
         symbol.show(ticker)
     except Exception as exc:
@@ -76,12 +94,6 @@ def set_chart(ticker: str, scale: str = "") -> Answer:
         except Exception:
             word = None
 
-    # Uncover the chart: a voice answer is only useful if the screen shows it.
-    try:
-        window.clear()
-    except Exception:
-        pass
-
     if word:
         return Answer(f"Showing {ticker} at {word}. Good luck.", shown, word)
     try:
@@ -93,6 +105,9 @@ def set_chart(ticker: str, scale: str = "") -> Answer:
 
 def cmd_read() -> str:
     """Report the chart's current symbol and scale."""
+    refused = _present()
+    if refused:
+        return refused
     try:
         ticker = symbol.current()
         _, word = timeframe.current()
@@ -103,6 +118,9 @@ def cmd_read() -> str:
 
 def cmd_snapshot() -> str:
     """A picture of the chart pane, so a caller far away can see it."""
+    refused = _present()
+    if refused:
+        return refused
     try:
         return snapshot.as_reply(snapshot.shrink(window.capture()))
     except Exception as exc:

chartremotely-0.2.10/chartremotely/window.py

@@ -0,0 +1,166 @@
+"""Make the chart visible, and prove what it shows.
+
+A voice command answered from across the room is only useful if the chart
+is actually on screen, and only trustworthy if the caller can see that it
+changed. Both matter more remotely than locally: at the desk you can see it
+worked; from another building a silent failure is indistinguishable from
+success.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+import Quartz
+
+from . import ax, config, layout, screen, snapshot, symbol
+
+#: NSApplicationActivateAllWindows | NSApplicationActivateIgnoringOtherApps:
+#: bring every thinkorswim window forward, even when another app is in front.
+ACTIVATE = 1 | 2
+#: Longest wait for the chart window to reach the screen after being raised.
+ON_SCREEN_WAIT = 2.0
+
+
+class NotOnScreen(RuntimeError):
+    """The chart window could not be brought on screen."""
+
+
+def _on_screen() -> list[dict]:
+    return list(Quartz.CGWindowListCopyWindowInfo(
+        Quartz.kCGWindowListOptionOnScreenOnly, Quartz.kCGNullWindowID) or [])
+
+
+def _frame(pid: int) -> dict | None:
+    """The largest on-screen thinkorswim window."""
+    return screen.largest(_on_screen(), pid)
+
+
+def _ax_frame(win) -> screen.Frame | None:
+    p, s = ax.position(win), ax.size(win)
+    return (p.x, p.y, s.width, s.height) if p and s else None
+
+
+def present(app=None) -> screen.Presented:
+    """Put the chart window in front of the viewer, before anything drives it.
+
+    Unhides thinkorswim, brings it forward, un-minimises and raises the chart
+    window (the one titled ``window_prefix``, which every driver works in),
+    waits until it is actually on screen - activation also switches to its
+    Space when it is full screen elsewhere - then hides the ordinary apps
+    overlapping it. Only regular apps are ever hidden: system overlays keep
+    permanent full-screen windows and are neither hideable nor in the way.
+
+    Run inside the chart lock, like every command that drives the chart.
+    """
+    app = app or ax.running_app()
+    pid = app.processIdentifier()
+    ax_app = ax.handle(app)
+    # Read from the process itself: NSRunningApplication's isHidden/isActive
+    # only refresh on a run loop, which the listener and relay never spin.
+    unhid = bool(ax.attr(ax_app, "AXHidden"))
+    raised = not ax.attr(ax_app, "AXFrontmost")
+    if unhid:
+        app.unhide()
+    app.activateWithOptions_(ACTIVATE)
+
+    prefix = config.load()["window_prefix"]
+    win = screen.wait_for(lambda: ax.window(ax_app, prefix), timeout=ON_SCREEN_WAIT)
+    if win is None:
+        raise NotOnScreen(f"no thinkorswim window titled {prefix!r}")
+    unminimized = bool(ax.attr(win, "AXMinimized"))
+    if unminimized:
+        ax.set_attr(win, "AXMinimized", False)
+    ax.perform(win, "AXRaise")
+    ax.set_attr(win, "AXMain", True)
+    ax.set_attr(win, "AXFocused", True)
+
+    def arrived():
+        frame = _ax_frame(win)
+        return frame and screen.showing(_on_screen(), pid, frame)
+
+    target = screen.wait_for(arrived, timeout=ON_SCREEN_WAIT)
+    if target is None:
+        raise NotOnScreen("the chart window did not come on screen")
+
+    hid = _uncover(pid, target["kCGWindowBounds"])
+    app.activateWithOptions_(ACTIVATE)
+    return screen.Presented(unhid=unhid, unminimized=unminimized,
+                            raised=raised or unminimized, hid=hid)
+
+
+def _uncover(pid: int, bounds: dict) -> tuple[str, ...]:
+    """Hide every ordinary app with a window over ``bounds``; their names."""
+    windows = _on_screen()
+    apps = {p: ax.app_for(p) for p in {w.get("kCGWindowOwnerPID") for w in windows} if p}
+    regular = {p: a for p, a in apps.items() if a is not None and a.activationPolicy() == 0}
+    hidden = []
+    # An app with a window on screen is not hidden, whatever a cached
+    # isHidden says; see present().
+    for p in screen.covering(windows, bounds, pid, regular):
+        a = regular[p]
+        a.hide()
+        hidden.append(a.localizedName() or str(p))
+    if hidden:
+        time.sleep(0.4)
+    return tuple(sorted(hidden))
+
+
+def capture(app=None) -> bytes:
+    """PNG of the chart's own pane, and nothing else in the window.
+
+    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
+    chart's symbol field; see :func:`snapshot.chart_crop` for why the rest of
+    the window never leaves this machine.
+    """
+    app = app or ax.running_app()
+    target = _frame(app.processIdentifier())
+    if target is None:
+        raise ax.NotRunning("no thinkorswim window on screen")
+    b = target["kCGWindowBounds"]
+    bounds = (int(b["X"]), int(b["Y"]), int(b["Width"]), int(b["Height"]))
+
+    # Hit-testing answers from the menu bar unless the app is in front.
+    ax.activate(app)
+    ax_app = ax.handle(app)
+    prefix = config.load()["window_prefix"]
+    hit = symbol.discover(ax_app, prefix)
+    if hit is None:
+        raise snapshot.ChartNotIsolated("no chart is visible")
+    panes = layout.panes(ax_app, prefix)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        shot = Path(tmp) / "window.png"
+        subprocess.run(["screencapture", "-x", "-o", "-l", str(target["kCGWindowNumber"]), str(shot)],
+                       check=True, capture_output=True)
+        crop = snapshot.chart_crop(hit, panes, bounds, _pixel_size(shot))
+        chart = Path(tmp) / "chart.png"
+        _crop(shot, chart, *crop)
+        return chart.read_bytes()
+
+
+def _image(path: Path):
+    from CoreFoundation import CFURLCreateWithFileSystemPath, kCFURLPOSIXPathStyle
+
+    url = CFURLCreateWithFileSystemPath(None, str(path), kCFURLPOSIXPathStyle, False)
+    return Quartz.CGImageSourceCreateImageAtIndex(Quartz.CGImageSourceCreateWithURL(url, None), 0, None)
+
+
+def _pixel_size(path: Path) -> tuple[int, int]:
+    image = _image(path)
+    return Quartz.CGImageGetWidth(image), Quartz.CGImageGetHeight(image)
+
+
+def _crop(src: Path, dst: Path, x: int, y: int, w: int, h: int) -> None:
+    from CoreFoundation import CFURLCreateWithFileSystemPath, kCFURLPOSIXPathStyle
+
+    region = Quartz.CGImageCreateWithImageInRect(_image(src), Quartz.CGRectMake(x, y, w, h))
+    out_url = CFURLCreateWithFileSystemPath(None, str(dst), kCFURLPOSIXPathStyle, False)
+    dest = Quartz.CGImageDestinationCreateWithURL(out_url, "public.png", 1, None)
+    Quartz.CGImageDestinationAddImage(dest, region, None)
+    Quartz.CGImageDestinationFinalize(dest)

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

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

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

@@ -18,6 +18,7 @@ chartremotely/relay.py
 chartremotely/requestlog.py
 chartremotely/resolve.py
 chartremotely/scales.py
+chartremotely/screen.py
 chartremotely/server.py
 chartremotely/services.py
 chartremotely/setup.py
@@ -41,6 +42,7 @@ tests/test_push.py
 tests/test_relay.py
 tests/test_requestlog.py
 tests/test_resolve.py
+tests/test_screen.py
 tests/test_setup.py
 tests/test_snapshot.py
 tests/test_stamp_changelog.py

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

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

chartremotely-0.2.10/tests/test_screen.py

@@ -0,0 +1,77 @@
+"""The pure half of bringing the chart in front: which window, whether it is back, what covers it."""
+
+from chartremotely import screen
+
+TOS, SAFARI, MAIL, OVERLAY = 10, 20, 30, 40
+
+
+def win(pid, x, y, w, h, layer=0):
+    return {"kCGWindowOwnerPID": pid, "kCGWindowLayer": layer,
+            "kCGWindowBounds": {"X": x, "Y": y, "Width": w, "Height": h}}
+
+
+CHART = win(TOS, 0, 25, 1600, 1000)
+
+
+def test_overlap_needs_shared_area_not_a_shared_edge():
+    a = {"X": 0, "Y": 0, "Width": 100, "Height": 100}
+    assert screen.overlaps(a, {"X": 50, "Y": 50, "Width": 100, "Height": 100})
+    assert not screen.overlaps(a, {"X": 100, "Y": 0, "Width": 50, "Height": 50})
+    assert not screen.overlaps(a, {"X": 0, "Y": 100, "Width": 50, "Height": 50})
+
+
+def test_largest_takes_only_the_apps_own_windows():
+    windows = [win(SAFARI, 0, 0, 3000, 3000), win(TOS, 0, 0, 200, 200), CHART]
+    assert screen.largest(windows, TOS) is CHART
+    assert screen.largest(windows, MAIL) is None
+
+
+def test_the_chart_is_showing_only_when_its_own_frame_is_on_screen():
+    detached = win(TOS, 1700, 0, 400, 300)
+    assert screen.showing([detached], TOS, (0, 25, 1600, 1000)) is None
+    assert screen.showing([detached, CHART], TOS, (0, 25, 1600, 1000)) is CHART
+    # A point of rounding between the two APIs is not a different window.
+    assert screen.showing([CHART], TOS, (1, 24, 1600, 1001)) is CHART
+    assert screen.showing([CHART], SAFARI, (0, 25, 1600, 1000)) is None
+
+
+def test_covering_names_each_overlapping_ordinary_app_once():
+    windows = [win(SAFARI, 100, 100, 500, 500), win(SAFARI, 200, 200, 50, 50),
+               win(MAIL, 2000, 0, 300, 300), CHART]
+    assert screen.covering(windows, CHART["kCGWindowBounds"], TOS,
+                           {SAFARI, MAIL}) == [SAFARI]
+
+
+def test_covering_never_touches_overlays_the_desktop_or_the_chart_itself():
+    windows = [win(OVERLAY, 0, 0, 3000, 2000, layer=25),     # not a regular app
+               win(SAFARI, 0, 0, 3000, 2000, layer=-2147483603),  # desktop layer
+               CHART]
+    assert screen.covering(windows, CHART["kCGWindowBounds"], TOS,
+                           {SAFARI, TOS}) == []
+
+
+def test_wait_for_returns_the_first_truthy_probe():
+    answers = iter([None, None, "here"])
+    t = [0.0]
+    got = screen.wait_for(lambda: next(answers), timeout=2.0, interval=0.1,
+                          clock=lambda: t[0], sleep=lambda s: t.__setitem__(0, t[0] + s))
+    assert got == "here"
+    assert abs(t[0] - 0.2) < 1e-9
+
+
+def test_wait_for_gives_up_after_the_timeout_having_probed_at_least_once():
+    probes = []
+    t = [0.0]
+    got = screen.wait_for(lambda: probes.append(1), timeout=0.5, interval=0.1,
+                          clock=lambda: t[0], sleep=lambda s: t.__setitem__(0, t[0] + s))
+    assert got is None
+    assert 5 <= len(probes) <= 7
+
+
+def test_presented_says_what_it_took():
+    assert not screen.Presented()
+    assert str(screen.Presented()) == "already in front"
+    done = screen.Presented(unhid=True, raised=True, hid=("Mail", "Safari"))
+    assert done
+    assert str(done) == "unhid; raised; hid Mail, Safari"
+    assert str(screen.Presented(unminimized=True, raised=True)) == "unminimized; raised"

chartremotely-0.2.9/chartremotely/window.py

@@ -1,134 +0,0 @@
-"""Make the chart visible, and prove what it shows.
-
-A voice command answered from across the room is only useful if the chart
-is actually on screen, and only trustworthy if the caller can see that it
-changed. Both matter more remotely than locally: at the desk you can see it
-worked; from another building a silent failure is indistinguishable from
-success.
-"""
-
-from __future__ import annotations
-
-import subprocess
-import tempfile
-import time
-from pathlib import Path
-
-import Quartz
-from AppKit import NSWorkspace
-
-from . import ax, config, layout, snapshot, symbol
-
-
-def _frame(pid: int) -> dict | None:
-    """Bounds of the largest on-screen thinkorswim window."""
-    best, best_area = None, -1
-    for w in Quartz.CGWindowListCopyWindowInfo(
-            Quartz.kCGWindowListOptionOnScreenOnly, Quartz.kCGNullWindowID):
-        if w.get("kCGWindowOwnerPID") != pid:
-            continue
-        b = w.get("kCGWindowBounds") or {}
-        area = b.get("Width", 0) * b.get("Height", 0)
-        if area > best_area:
-            best, best_area = w, area
-    return best
-
-
-def _overlaps(a: dict, b: dict) -> bool:
-    return not (a.get("X", 0) + a.get("Width", 0) <= b.get("X", 0)
-                or a.get("X", 0) >= b.get("X", 0) + b.get("Width", 0)
-                or a.get("Y", 0) + a.get("Height", 0) <= b.get("Y", 0)
-                or a.get("Y", 0) >= b.get("Y", 0) + b.get("Height", 0))
-
-
-def clear(app=None) -> list[str]:
-    """Hide every ordinary app overlapping the chart, then raise it.
-
-    Only regular apps are touched - system overlays keep permanent
-    full-screen windows and are neither hideable nor actually in the way.
-    """
-    app = app or ax.running_app()
-    pid = app.processIdentifier()
-    target = _frame(pid)
-    if target is None:
-        return []
-    bounds = target["kCGWindowBounds"]
-
-    regular = {a.processIdentifier(): a
-               for a in NSWorkspace.sharedWorkspace().runningApplications()
-               if a.activationPolicy() == 0 and a.processIdentifier() != pid}
-
-    covering = {w["kCGWindowOwnerPID"]
-                for w in Quartz.CGWindowListCopyWindowInfo(
-                    Quartz.kCGWindowListOptionOnScreenOnly, Quartz.kCGNullWindowID)
-                if w.get("kCGWindowOwnerPID") in regular
-                and w.get("kCGWindowLayer", 0) >= 0
-                and _overlaps(w.get("kCGWindowBounds") or {}, bounds)}
-
-    hidden = []
-    for p in covering:
-        a = regular[p]
-        if not a.isHidden():
-            a.hide()
-            hidden.append(a.localizedName() or str(p))
-    if hidden:
-        time.sleep(0.4)
-    app.activateWithOptions_(2)
-    return sorted(hidden)
-
-
-def capture(app=None) -> bytes:
-    """PNG of the chart's own pane, and nothing else in the window.
-
-    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
-    chart's symbol field; see :func:`snapshot.chart_crop` for why the rest of
-    the window never leaves this machine.
-    """
-    app = app or ax.running_app()
-    target = _frame(app.processIdentifier())
-    if target is None:
-        raise ax.NotRunning("no thinkorswim window on screen")
-    b = target["kCGWindowBounds"]
-    bounds = (int(b["X"]), int(b["Y"]), int(b["Width"]), int(b["Height"]))
-
-    # Hit-testing answers from the menu bar unless the app is in front.
-    ax.activate(app)
-    ax_app = ax.handle(app)
-    prefix = config.load()["window_prefix"]
-    hit = symbol.discover(ax_app, prefix)
-    if hit is None:
-        raise snapshot.ChartNotIsolated("no chart is visible")
-    panes = layout.panes(ax_app, prefix)
-
-    with tempfile.TemporaryDirectory() as tmp:
-        shot = Path(tmp) / "window.png"
-        subprocess.run(["screencapture", "-x", "-o", "-l", str(target["kCGWindowNumber"]), str(shot)],
-                       check=True, capture_output=True)
-        crop = snapshot.chart_crop(hit, panes, bounds, _pixel_size(shot))
-        chart = Path(tmp) / "chart.png"
-        _crop(shot, chart, *crop)
-        return chart.read_bytes()
-
-
-def _image(path: Path):
-    from CoreFoundation import CFURLCreateWithFileSystemPath, kCFURLPOSIXPathStyle
-
-    url = CFURLCreateWithFileSystemPath(None, str(path), kCFURLPOSIXPathStyle, False)
-    return Quartz.CGImageSourceCreateImageAtIndex(Quartz.CGImageSourceCreateWithURL(url, None), 0, None)
-
-
-def _pixel_size(path: Path) -> tuple[int, int]:
-    image = _image(path)
-    return Quartz.CGImageGetWidth(image), Quartz.CGImageGetHeight(image)
-
-
-def _crop(src: Path, dst: Path, x: int, y: int, w: int, h: int) -> None:
-    from CoreFoundation import CFURLCreateWithFileSystemPath, kCFURLPOSIXPathStyle
-
-    region = Quartz.CGImageCreateWithImageInRect(_image(src), Quartz.CGRectMake(x, y, w, h))
-    out_url = CFURLCreateWithFileSystemPath(None, str(dst), kCFURLPOSIXPathStyle, False)
-    dest = Quartz.CGImageDestinationCreateWithURL(out_url, "public.png", 1, None)
-    Quartz.CGImageDestinationAddImage(dest, region, None)
-    Quartz.CGImageDestinationFinalize(dest)