chartremotely 0.3.6__tar.gz → 0.3.8__tar.gz

{chartremotely-0.3.6 → chartremotely-0.3.8}/PKG-INFO

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

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/cli.py

@@ -128,7 +128,7 @@ def main(argv: list[str] | None = None) -> int:
 
 
 def _looks_like_ticker(text: str) -> bool:
-    from .symbol import TICKER
+    from .resolve import TICKER
     return bool(TICKER.match(text.strip().upper()))
 
 

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/doctor.py

@@ -7,6 +7,7 @@ check names the fix, not just the symptom.
 
 from __future__ import annotations
 
+import os
 import urllib.error
 import urllib.request
 
@@ -33,18 +34,45 @@ def _check_app() -> tuple[str, str]:
     return OK, f"thinkorswim running (pid {app.processIdentifier()})"
 
 
-def _check_accessibility() -> tuple[str, str]:
-    """A denied grant looks like an empty tree, not an error."""
-    from . import ax
-    try:
-        app = ax.running_app()
-    except ax.NotRunning:
-        return WARN, "skipped - thinkorswim is not running"
-    windows = ax.attr(ax.handle(app), "AXWindows")
-    if not windows:
-        return BAD, ("no accessibility access - grant it in System Settings > "
-                     "Privacy & Security > Accessibility. This cannot be automated.")
-    return OK, f"accessibility granted ({len(windows)} windows visible)"
+def permission_verdict(granted: dict) -> tuple[str, str]:
+    """What the services' own Python holds; see :func:`services.probe_permissions`."""
+    if not granted:
+        return BAD, "the permission check did not answer - run: chartremotely setup"
+    missing = [name for name, key in (("Accessibility", "accessibility"),
+                                      ("Screen Recording", "screen_recording")) if not granted.get(key)]
+    if missing:
+        python = granted.get("python", "the services' Python")
+        return BAD, (f"{' and '.join(missing)} off for {python} - "
+                     "run: chartremotely setup (a Python upgrade revokes both)")
+    return OK, "Accessibility and Screen Recording allowed for the services' Python"
+
+
+def _check_permissions() -> tuple[str, str]:
+    """Asked as a launchd job, as the services run: the Terminal's own grants say nothing about theirs."""
+    import tempfile
+    from pathlib import Path
+
+    from . import services
+    return permission_verdict(services.probe_permissions(
+        request=False, out=Path(tempfile.gettempdir()) / "chartremotely-permissions.json"))
+
+
+def service_verdict(running: dict[str, str | None], exists=os.path.exists) -> tuple[str, str]:
+    """Each service, and whether the Python it runs is still on disk."""
+    stopped = [name for name, python in running.items() if python is None]
+    orphaned = [name for name, python in running.items() if python and not exists(python)]
+    if orphaned:
+        kick = "; ".join(f"launchctl kickstart -k gui/$UID/com.chartremotely.{name}" for name in orphaned)
+        return BAD, (f"{', '.join(orphaned)} still on a Python that was upgraded away - "
+                     f"restart: {kick}, then run: chartremotely doctor")
+    if stopped:
+        return BAD, f"{', '.join(stopped)} not running - run: chartremotely setup"
+    return OK, "serve and relay running"
+
+
+def _check_services() -> tuple[str, str]:
+    from . import services
+    return service_verdict({name: services.running_python(name) for name in services.LABELS})
 
 
 def _check_controls() -> tuple[str, str]:
@@ -97,7 +125,8 @@ def _check_listener() -> tuple[str, str]:
 CHECKS = (
     ("PyObjC", _check_pyobjc),
     ("thinkorswim", _check_app),
-    ("Accessibility", _check_accessibility),
+    ("Services", _check_services),
+    ("Permissions", _check_permissions),
     ("Chart controls", _check_controls),
     ("Registry", _check_registry),
     ("Listener", _check_listener),

chartremotely-0.3.8/chartremotely/registry.py

@@ -0,0 +1,122 @@
+"""The security registry: SEC issuers plus listed ETFs, cached locally.
+
+The SEC file holds roughly 10,500 US issuers, ordered by prominence, which
+makes the index a usable tie-breaker: NVDA, AAPL and GOOGL are the first
+three entries. It lists a fund only when the fund files as its own company
+(SPY, GLD), so the sector and thematic ETFs that file as a series of a
+parent trust - XBI, XLE, QQQ, SMH - are absent from it.
+
+Nasdaq Trader's symbol directory fills that gap: every US-listed security,
+each flagged as an ETF or not, with its full name. Only its ETF rows are
+taken, ranked after every SEC issuer, so a spoken company name still finds
+the company before a fund that shares a word with it.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.request
+
+from .config import DATA_DIR
+
+SEC_URL = "https://www.sec.gov/files/company_tickers.json"
+NASDAQ_URL = "https://www.nasdaqtrader.com/dynamic/SymDir/nasdaqtraded.txt"
+CACHE = DATA_DIR / "tickers.json"
+ETF_CACHE = DATA_DIR / "etfs.json"
+MAX_AGE = 7 * 24 * 3600
+# The SEC requires a User-Agent carrying a contact address and answers 403
+# without one. A repository URL alone is not enough.
+DEFAULT_CONTACT = "chartremotely@example.com"
+
+
+def _user_agent() -> str:
+    from .config import load
+    contact = load().get("contact") or DEFAULT_CONTACT
+    # SEC's documented format is plain "Name email". Anything fancier is
+    # rejected: a User-Agent carrying a URL answers 403, as does one with no
+    # contact address at all.
+    return f"ChartRemotely {contact}"
+
+
+def _fresh(path=CACHE) -> bool:
+    return path.exists() and time.time() - path.stat().st_mtime < MAX_AGE
+
+
+def _store(path, rows: list) -> None:
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(rows))
+    tmp.replace(path)
+
+
+def refresh() -> list[dict]:
+    request = urllib.request.Request(SEC_URL, headers={"User-Agent": _user_agent()})
+    with urllib.request.urlopen(request, timeout=20) as response:
+        raw = json.load(response)
+    rows = [{"t": v["ticker"], "n": v["title"], "r": rank}
+            for rank, v in enumerate(raw.values())]
+    _store(CACHE, rows)
+    return rows
+
+
+def parse_etfs(text: str) -> list[list[str]]:
+    """``[symbol, name]`` for each live ETF in a Nasdaq Trader directory.
+
+    Pipe-delimited with a header row and a closing "File Creation Time"
+    line. Test issues and symbols no longer traded are dropped.
+    """
+    lines = text.splitlines()
+    if not lines:
+        return []
+    head = lines[0].split("|")
+    try:
+        traded, sym, name, etf, test = (head.index(c) for c in (
+            "Nasdaq Traded", "Symbol", "Security Name", "ETF", "Test Issue"))
+    except ValueError:
+        return []
+    out = []
+    for line in lines[1:]:
+        f = line.split("|")
+        if len(f) < len(head):
+            continue
+        if f[traded] == "Y" and f[etf] == "Y" and f[test] == "N" and f[sym]:
+            out.append([f[sym].strip(), f[name].strip()])
+    return out
+
+
+def refresh_etfs() -> list[list[str]]:
+    request = urllib.request.Request(NASDAQ_URL, headers={"User-Agent": _user_agent()})
+    with urllib.request.urlopen(request, timeout=20) as response:
+        etfs = parse_etfs(response.read().decode("utf-8", "replace"))
+    if etfs:
+        _store(ETF_CACHE, etfs)
+    return etfs
+
+
+def _etfs(force: bool) -> list[list[str]]:
+    """The ETF rows, refreshed weekly. Never what breaks a lookup: when the
+    directory cannot be fetched, the last copy serves, else no ETFs."""
+    if force or not _fresh(ETF_CACHE):
+        try:
+            etfs = refresh_etfs()
+            if etfs:
+                return etfs
+        except (OSError, ValueError):
+            pass
+    try:
+        return json.loads(ETF_CACHE.read_text())
+    except (OSError, ValueError):
+        return []
+
+
+def merge(sec: list[dict], etfs: list[list[str]]) -> list[dict]:
+    """SEC rows first, then each ETF the SEC file lacks, ranked after them."""
+    have = {r["t"] for r in sec}
+    extra = [(t, n) for t, n in etfs if t not in have]
+    return sec + [{"t": t, "n": n, "r": len(sec) + i} for i, (t, n) in enumerate(extra)]
+
+
+def load(force: bool = False) -> list[dict]:
+    sec = refresh() if force or not _fresh() else json.loads(CACHE.read_text())
+    return merge(sec, _etfs(force))

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/resolve.py

@@ -30,7 +30,13 @@ import difflib
 import re
 from dataclasses import dataclass, field
 
-__all__ = ["Decision", "candidates", "decide", "normalize", "phonetic", "resolve", "spelled"]
+__all__ = ["TICKER", "Decision", "candidates", "decide", "normalize", "phonetic", "resolve", "spelled"]
+
+# A stock (PLTR), share class (BRK/B), crypto pair (BTC/USD), index ($SPX)
+# or dated future (/ESZ25:XCME). thinkorswim's symbol field must hold one
+# of these before the agent types into it, so a shape left out here refuses
+# every request that follows it.
+TICKER = re.compile(r"^[./$]?[A-Z][A-Z0-9]{0,5}([/.][A-Z]{1,4})?(:[A-Z]+)?$")
 
 # Corporate furniture, stripped from both sides before comparison. "and"
 # is here because "&" normalises to it, so DEERE & CO reduces to "deere".

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/services.py

@@ -69,6 +69,31 @@ def loaded(label: str) -> bool:
                           capture_output=True, check=False).returncode == 0
 
 
+def pid_in(printed: str) -> int | None:
+    """The ``pid = N`` line of ``launchctl print``; None when the job is not running."""
+    for line in printed.splitlines():
+        key, _, value = line.strip().partition(" = ")
+        if key == "pid" and value.isdigit():
+            return int(value)
+    return None
+
+
+def running_python(command: str) -> str | None:
+    """The executable a running service was started from, or None if it is not running.
+
+    macOS grants Accessibility and Screen Recording to that exact file. A
+    Homebrew upgrade replaces it while the service keeps running the old,
+    deleted one - which then holds neither grant.
+    """
+    printed = subprocess.run(["launchctl", "print", f"{_domain()}/{LABELS[command]}"],
+                             capture_output=True, text=True, check=False)
+    pid = pid_in(printed.stdout) if printed.returncode == 0 else None
+    if pid is None:
+        return None
+    ps = subprocess.run(["ps", "-o", "comm=", "-p", str(pid)], capture_output=True, text=True, check=False)
+    return ps.stdout.strip() or None
+
+
 def install(command: str, settle: float = 10.0) -> Path:
     """Write and (re)start one service. Idempotent.
 

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/setup.py

@@ -294,7 +294,9 @@ def run(ask: Ask = input, say: Say = print, operator_url: str = OPERATOR_URL) ->
     out.step(4, total, "Permissions")
     probe = Path(tempfile.gettempdir()) / "chartremotely-permissions.json"
     granted = services.probe_permissions(request=True, out=probe)
+    asked = False
     while not (granted.get("accessibility") and granted.get("screen_recording")):
+        asked = True
         python = granted.get("python", "the Python that runs ChartRemotely")
         missing = [name for name, key in (("Accessibility", "accessibility"),
                                           ("Screen Recording", "screen_recording")) if not granted.get(key)]
@@ -302,8 +304,14 @@ def run(ask: Ask = input, say: Say = print, operator_url: str = OPERATOR_URL) ->
         out.say(python)
         pane = "Privacy_Accessibility" if not granted.get("accessibility") else "Privacy_ScreenCapture"
         subprocess.run(["open", f"x-apple.systempreferences:com.apple.preference.security?{pane}"], check=False)
-        out.ask("Turn it on in System Settings, then press Return… ")
+        # The list's + picker will not select a bare executable; Finder can drag it in.
+        subprocess.run(["open", "-R", python], check=False)
+        out.ask("Switch it on in that list (or drag it in from the Finder window), then press Return… ")
         granted = services.probe_permissions(request=False, out=probe)
+    if asked:
+        # A grant reaches a running process only when it restarts.
+        for command in ("serve", "relay"):
+            services.install(command)
     out.ok("Accessibility and Screen Recording are allowed.")
 
     # 5. Hearing: the speech model, and the display names a sentence may say.

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/snapshot.py

@@ -38,6 +38,29 @@ class ChartNotIsolated(LookupError):
     """The chart's own pane could not be told apart from the whole window."""
 
 
+class CaptureFailed(RuntimeError):
+    """macOS would not photograph the window; the message says why."""
+
+
+#: The fix for a refused capture. The grant belongs to the exact Python the
+#: services run, so a Homebrew upgrade of that Python silently revokes it.
+SCREEN_RECORDING_OFF = ("Screen Recording is off for this agent's Python "
+                        "(a Python upgrade revokes it). Run: chartremotely setup")
+
+
+def capture_failed(stderr: str, allowed: bool) -> CaptureFailed:
+    """Name why ``screencapture`` failed, in words a reply can carry.
+
+    ``allowed`` is whether this process holds Screen Recording. Without it,
+    that is the cause whatever screencapture printed; with it, its own first
+    line is the best account there is.
+    """
+    if not allowed:
+        return CaptureFailed(SCREEN_RECORDING_OFF)
+    said = next((line.strip() for line in (stderr or "").splitlines() if line.strip()), "")
+    return CaptureFailed(f"screencapture failed: {said}" if said else "screencapture failed and said nothing")
+
+
 def chart_crop(hit: tuple[int, int], panes: list[Rect], window: Rect,
                image: tuple[int, int]) -> Rect:
     """The chart's pane, in the capture's own pixels.

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/symbol.py

@@ -14,9 +14,7 @@ import time
 import Quartz
 
 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]+)?$")
+from .resolve import TICKER
 
 #: Longest show() waits for the chart's title to name the new symbol.
 COMMIT_WAIT = 3.0

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/understand.py

@@ -2,7 +2,7 @@
 
 Siri's dictation (and, next, a Whisper transcription of the whole
 utterance) matches against all of English. What we need back is small: a
-company from the SEC list, one of ten time frames, and the name of a
+company or ETF from the registry, one of ten time frames, and the name of a
 display. This module takes the text as heard - "Palantir half on mac mini",
 "shop thirty minutes", "GE daily on the studio", "apple as is on desk" - and
 recovers those three, refusing rather than guessing.
@@ -22,7 +22,7 @@ It works right to left, the way people say it:
    symbols charted lately as a prior. Too close to call is an answer too:
    the options, so the reply can ask.
 
-Pure and deterministic: no LLM, no network beyond the cached SEC registry.
+Pure and deterministic: no LLM, no network beyond the cached security registry.
 """
 
 from __future__ import annotations
@@ -183,7 +183,7 @@ def understand(text: str, *, recent: list[str], displays: list[str],
 
     ``recent``: symbols charted lately, most recent first (:mod:`recent`).
     ``displays``: the owner's display names, to split off "where". ``rows``:
-    the SEC registry, loaded from its cache when not given.
+    the security registry, loaded from its cache when not given.
     """
     if rows is None:
         from . import registry

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely/window.py

@@ -140,8 +140,10 @@ def capture(app=None) -> bytes:
 
     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)
+        ran = subprocess.run(["screencapture", "-x", "-o", "-l", str(target["kCGWindowNumber"]), str(shot)],
+                             check=False, capture_output=True, text=True)
+        if ran.returncode != 0 or not shot.exists():
+            raise snapshot.capture_failed(ran.stderr, bool(Quartz.CGPreflightScreenCaptureAccess()))
         crop = snapshot.chart_crop(hit, panes, bounds, _pixel_size(shot))
         chart = Path(tmp) / "chart.png"
         _crop(shot, chart, *crop)

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely.egg-info/PKG-INFO

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

{chartremotely-0.3.6 → chartremotely-0.3.8}/chartremotely.egg-info/SOURCES.txt

@@ -46,11 +46,13 @@ chartremotely.egg-info/requires.txt
 chartremotely.egg-info/top_level.txt
 chartremotely/assets/shortcut.plist
 tests/test_changelog.py
+tests/test_doctor.py
 tests/test_hearing.py
 tests/test_patron.py
 tests/test_popups.py
 tests/test_push.py
 tests/test_recent.py
+tests/test_registry.py
 tests/test_relay.py
 tests/test_requestlog.py
 tests/test_resolve.py

{chartremotely-0.3.6 → chartremotely-0.3.8}/pyproject.toml

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

chartremotely-0.3.8/tests/test_doctor.py

@@ -0,0 +1,42 @@
+"""Doctor's verdicts on the services and their grants - the parts that need no Mac."""
+
+from chartremotely import doctor, services
+
+OLD = "/opt/homebrew/Cellar/python@3.12/3.12.13/Frameworks/Python.framework/Versions/3.12/bin/python3.12"
+NEW = OLD.replace("3.12.13", "3.12.15_1")
+
+
+def test_both_grants_held_is_ok():
+    status, _ = doctor.permission_verdict({"python": NEW, "accessibility": True, "screen_recording": True})
+    assert status == doctor.OK
+
+
+def test_a_missing_grant_names_it_the_python_and_the_fix():
+    status, detail = doctor.permission_verdict({"python": NEW, "accessibility": True, "screen_recording": False})
+    assert status == doctor.BAD
+    assert "Screen Recording" in detail and "Accessibility" not in detail
+    assert NEW in detail and "chartremotely setup" in detail
+
+
+def test_a_probe_that_never_answered_fails():
+    assert doctor.permission_verdict({})[0] == doctor.BAD
+
+
+def test_a_service_on_a_deleted_python_says_restart_it():
+    status, detail = doctor.service_verdict({"serve": NEW, "relay": OLD}, exists=lambda p: p == NEW)
+    assert status == doctor.BAD
+    assert "com.chartremotely.relay" in detail and "com.chartremotely.serve" not in detail
+
+
+def test_a_stopped_service_points_at_setup():
+    status, detail = doctor.service_verdict({"serve": None, "relay": NEW}, exists=lambda p: True)
+    assert status == doctor.BAD and "serve" in detail and "setup" in detail
+
+
+def test_both_running_on_a_live_python_is_ok():
+    assert doctor.service_verdict({"serve": NEW, "relay": NEW}, exists=lambda p: True)[0] == doctor.OK
+
+
+def test_launchctl_print_yields_the_pid_only_while_running():
+    assert services.pid_in("com.chartremotely.relay = {\n\tstate = running\n\tpid = 12804\n}") == 12804
+    assert services.pid_in("com.chartremotely.relay = {\n\tstate = not running\n}") is None

chartremotely-0.3.8/tests/test_registry.py

@@ -0,0 +1,119 @@
+"""The registry merges SEC issuers with Nasdaq Trader's ETFs.
+
+The ETF rows exist because "XBI swing scale" found nothing: the SEC file
+lists a fund only when it files as its own company, and the sector ETFs
+file as a series of a parent trust.
+"""
+
+import pytest
+
+from chartremotely import registry
+from chartremotely.resolve import TICKER, resolve
+from chartremotely.understand import understand
+
+# The real directory's header, rows as published, and its closing line.
+DIRECTORY = """\
+Nasdaq Traded|Symbol|Security Name|Listing Exchange|Market Category|ETF|Round Lot Size|Test Issue|Financial Status|CQS Symbol|NASDAQ Symbol|NextShares
+Y|XBI|State Street SPDR S&P Biotech ETF|P| |Y|100|N||XBI|XBI|N
+Y|XLE|State Street Energy Select Sector SPDR ETF|P| |Y|100|N||XLE|XLE|N
+Y|QQQ|Invesco QQQ Trust, Series 1|Q|G|Y|40|N|N||QQQ|N
+Y|SPY|SPDR S&P 500 ETF Trust|P| |Y|100|N||SPY|SPY|N
+Y|STRC|Strategy Inc - Variable Rate Series A Perpetual Stretch Preferred Stock|Q|Q|N|100|N|N||STRC|N
+Y|ZXZZT|NASDAQ TEST STOCK|Q|G|Y|100|Y|N||ZXZZT|N
+N|GONE|Delisted Example ETF|P| |Y|100|N||GONE|GONE|N
+File Creation Time: 1021202609:01|||||||||||
+"""
+
+SEC = [
+    {"t": "NVDA", "n": "NVIDIA CORP", "r": 0},
+    {"t": "PLTR", "n": "Palantir Technologies Inc.", "r": 1},
+    {"t": "XOM", "n": "EXXON MOBIL CORP", "r": 2},
+    {"t": "KRYS", "n": "Krystal Biotech, Inc.", "r": 3},
+    {"t": "SPY", "n": "SPDR S&P 500 ETF TRUST", "r": 4},
+]
+
+
+def test_only_live_etfs_are_taken():
+    assert registry.parse_etfs(DIRECTORY) == [
+        ["XBI", "State Street SPDR S&P Biotech ETF"],
+        ["XLE", "State Street Energy Select Sector SPDR ETF"],
+        ["QQQ", "Invesco QQQ Trust, Series 1"],
+        ["SPY", "SPDR S&P 500 ETF Trust"],
+    ]
+
+
+@pytest.mark.parametrize("text", ["", "not a directory\n", "Symbol|Name\nXBI|x\n"])
+def test_an_unexpected_directory_yields_nothing(text):
+    assert registry.parse_etfs(text) == []
+
+
+def test_etfs_rank_after_every_sec_issuer_and_never_duplicate_one():
+    rows = registry.merge(SEC, registry.parse_etfs(DIRECTORY))
+    assert [r["t"] for r in rows] == ["NVDA", "PLTR", "XOM", "KRYS", "SPY", "XBI", "XLE", "QQQ"]
+    assert [r["r"] for r in rows] == list(range(8))
+    # The SEC's own SPY row wins over the directory's.
+    assert next(r for r in rows if r["t"] == "SPY")["n"] == "SPDR S&P 500 ETF TRUST"
+
+
+@pytest.fixture
+def caches(tmp_path, monkeypatch):
+    monkeypatch.setattr(registry, "DATA_DIR", tmp_path)
+    monkeypatch.setattr(registry, "CACHE", tmp_path / "tickers.json")
+    monkeypatch.setattr(registry, "ETF_CACHE", tmp_path / "etfs.json")
+    monkeypatch.setattr(registry, "refresh", lambda: list(SEC))
+    return tmp_path
+
+
+def test_unreachable_directory_serves_the_last_copy(caches, monkeypatch):
+    registry._store(registry.ETF_CACHE, [["XBI", "State Street SPDR S&P Biotech ETF"]])
+
+    def down():
+        raise OSError("nasdaqtrader.com unreachable")
+
+    monkeypatch.setattr(registry, "refresh_etfs", down)
+    rows = registry.load(force=True)
+    assert [r["t"] for r in rows][-1] == "XBI"
+
+
+def test_unreachable_directory_with_no_copy_still_loads_the_sec_file(caches, monkeypatch):
+    def down():
+        raise OSError("nasdaqtrader.com unreachable")
+
+    monkeypatch.setattr(registry, "refresh_etfs", down)
+    assert registry.load(force=True) == SEC
+
+
+@pytest.mark.parametrize("shape", [
+    "PLTR", "F", "BRK/B", "BTC/USD", "ETH/USD", "$SPX", ".SPX", "/ES", "/ESZ25:XCME", "XBI",
+])
+def test_ticker_shapes_thinkorswim_shows(shape):
+    assert TICKER.match(shape)
+
+
+@pytest.mark.parametrize("junk", ["", "palantir", "PLTR INC", "12AB", "BTC/USDTXX", "/"])
+def test_not_ticker_shaped(junk):
+    assert not TICKER.match(junk)
+
+
+ROWS = registry.merge(SEC, registry.parse_etfs(DIRECTORY))
+
+
+@pytest.mark.parametrize("said,expected", [
+    ("XBI", "XBI"),
+    ("x b i", "XBI"),
+    ("ex bee eye", "XBI"),
+    ("XLE", "XLE"),
+    ("x l e", "XLE"),
+    ("q q q", "QQQ"),
+    ("energy select sector", "XLE"),
+    # Companies still find themselves first.
+    ("palantir", "PLTR"),
+    ("exxon mobil", "XOM"),
+])
+def test_etfs_resolve_by_ticker_and_by_name(said, expected):
+    assert resolve(said, ROWS) == expected
+
+
+def test_an_etf_with_a_scale_and_a_display():
+    u = understand("XBI swing scale on Mac mini", recent=[], displays=["Mac mini"], rows=ROWS)
+    assert (u.ticker, u.scale, u.where) == ("XBI", "swing", "Mac mini")

{chartremotely-0.3.6 → chartremotely-0.3.8}/tests/test_snapshot.py

@@ -61,3 +61,23 @@ def test_a_point_outside_every_pane_is_refused():
 def test_the_crop_never_runs_past_the_image():
     x, y, w, h = snapshot.chart_crop((10, 10), [(-50, -50, 400, 400)], (0, 0, 1000, 1000), (1000, 1000))
     assert (x, y) == (0, 0) and w <= 1000 and h <= 1000
+
+
+def test_a_refused_capture_names_screen_recording_and_its_fix():
+    failed = snapshot.capture_failed("could not create image from window\n", allowed=False)
+    assert isinstance(failed, snapshot.CaptureFailed)
+    assert "Screen Recording" in str(failed) and "chartremotely setup" in str(failed)
+
+
+def test_an_allowed_capture_that_fails_reports_what_screencapture_said():
+    failed = snapshot.capture_failed("\n  could not create image from window\nmore\n", allowed=True)
+    assert str(failed) == "screencapture failed: could not create image from window"
+
+
+def test_a_silent_failure_still_says_something():
+    assert "said nothing" in str(snapshot.capture_failed("", allowed=True))
+
+
+def test_the_screen_recording_message_survives_the_reply_limit():
+    # vocab._short keeps 120 characters; the fix must not be cut off.
+    assert len(snapshot.SCREEN_RECORDING_OFF) <= 120

chartremotely-0.3.6/chartremotely/registry.py

@@ -1,53 +0,0 @@
-"""The SEC company registry, cached locally.
-
-Roughly 10,500 US issuers including ETFs. Ordered by prominence in the
-source file, which makes the index a usable tie-breaker: NVDA, AAPL and
-GOOGL are the first three entries.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-import urllib.request
-
-from .config import DATA_DIR
-
-SEC_URL = "https://www.sec.gov/files/company_tickers.json"
-CACHE = DATA_DIR / "tickers.json"
-MAX_AGE = 7 * 24 * 3600
-# The SEC requires a User-Agent carrying a contact address and answers 403
-# without one. A repository URL alone is not enough.
-DEFAULT_CONTACT = "chartremotely@example.com"
-
-
-def _user_agent() -> str:
-    from .config import load
-    contact = load().get("contact") or DEFAULT_CONTACT
-    # SEC's documented format is plain "Name email". Anything fancier is
-    # rejected: a User-Agent carrying a URL answers 403, as does one with no
-    # contact address at all.
-    return f"ChartRemotely {contact}"
-
-
-def _fresh() -> bool:
-    return CACHE.exists() and time.time() - CACHE.stat().st_mtime < MAX_AGE
-
-
-def refresh() -> list[dict]:
-    request = urllib.request.Request(SEC_URL, headers={"User-Agent": _user_agent()})
-    with urllib.request.urlopen(request, timeout=20) as response:
-        raw = json.load(response)
-    rows = [{"t": v["ticker"], "n": v["title"], "r": rank}
-            for rank, v in enumerate(raw.values())]
-    DATA_DIR.mkdir(parents=True, exist_ok=True)
-    tmp = CACHE.with_suffix(".tmp")
-    tmp.write_text(json.dumps(rows))
-    tmp.replace(CACHE)
-    return rows
-
-
-def load(force: bool = False) -> list[dict]:
-    if force or not _fresh():
-        return refresh()
-    return json.loads(CACHE.read_text())