chartremotely 0.2.10__tar.gz → 0.2.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.10
+Version: 0.2.12
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -345,8 +345,21 @@ expired. Answer the DM on your phone to renew." — a fresh DM is already on its
 way, and once you answer it (within about half an hour) the next command
 works again.
 
+**What Siri heard.** Dictation matches against all of English, so the Mac
+repairs what it hears against the three small vocabularies it actually needs:
+companies in the SEC list, the ten time frames, and your display names. A
+scale may be a mnemonic, a bar size ("thirty minutes", "an hour", "four
+hours", "a day") or one word that sounds like exactly one mnemonic ("have",
+"alf" are half). A company may be mis-heard ("volunteer", "pal and tear" are
+Palantir; "shop if y" is Shopify); when two companies are too close to call
+you are asked - "Did you mean PS (Pershing Square) or MSGS (Madison Square
+Garden)?" - rather than shown the wrong chart, and the symbols you chart
+lately settle a near-tie. `understand()` parses a whole sentence the same way
+("Palantir half on the mini").
+
 Each command handled is logged as one line — time, the command's first word,
-the "Where?" as said, and the reply if it was an ERR — plus one line when its
+the "Where?" as said, what was heard for a company or scale lookup, and the
+reply if it was an ERR — plus one line when its
 tool call ends (the tool, "Where?" and any refusal) — to
 `~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
 (from the operator). Never a token, a secret or a picture.

{chartremotely-0.2.10 → chartremotely-0.2.12}/README.md

@@ -121,8 +121,21 @@ expired. Answer the DM on your phone to renew." — a fresh DM is already on its
 way, and once you answer it (within about half an hour) the next command
 works again.
 
+**What Siri heard.** Dictation matches against all of English, so the Mac
+repairs what it hears against the three small vocabularies it actually needs:
+companies in the SEC list, the ten time frames, and your display names. A
+scale may be a mnemonic, a bar size ("thirty minutes", "an hour", "four
+hours", "a day") or one word that sounds like exactly one mnemonic ("have",
+"alf" are half). A company may be mis-heard ("volunteer", "pal and tear" are
+Palantir; "shop if y" is Shopify); when two companies are too close to call
+you are asked - "Did you mean PS (Pershing Square) or MSGS (Madison Square
+Garden)?" - rather than shown the wrong chart, and the symbols you chart
+lately settle a near-tie. `understand()` parses a whole sentence the same way
+("Palantir half on the mini").
+
 Each command handled is logged as one line — time, the command's first word,
-the "Where?" as said, and the reply if it was an ERR — plus one line when its
+the "Where?" as said, what was heard for a company or scale lookup, and the
+reply if it was an ERR — plus one line when its
 tool call ends (the tool, "Where?" and any refusal) — to
 `~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
 (from the operator). Never a token, a secret or a picture.

{chartremotely-0.2.10 → chartremotely-0.2.12}/chartremotely/patron.py

@@ -28,7 +28,7 @@ import threading
 import time
 from collections.abc import Callable
 
-from . import config, keystore, mcpclient, requestlog
+from . import config, keystore, mcpclient, recent, requestlog
 
 ERR = "ERR "
 #: How long a spoken reply waits for an early refusal before handing off.
@@ -134,6 +134,9 @@ def send(command: str, where: str, cfg: dict | None = None) -> str:
         payload = _call(base, tool, envelope)
         box["payload"] = payload
         settle(base, npub, tool, wanted, payload)
+        if tool == "chart_show_chart" and refusal(payload) is None \
+                and payload.get("error_code") not in PROOF_CODES:
+            recent.remember(args["security"])
         done.set()
 
     threading.Thread(target=work, name=f"call-{tool}", daemon=True).start()

chartremotely-0.2.12/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.12/chartremotely/recent.py

@@ -0,0 +1,50 @@
+"""The symbols this Mac charted lately: a personal prior for what was said.
+
+When a spoken name lands between two companies, the one you chart is the one
+you meant (see :func:`resolve.decide`). The list is kept most recent first,
+at most :data:`KEEP` long, in ``~/.config/chartremotely/recent.json``, and is
+written only when a chart change succeeded. It holds ticker symbols and
+nothing else - never a token, a name as said or a secret.
+
+Stdlib only; every function swallows its own errors, because a lost prior
+must never cost a reply.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+from .config import CONFIG_DIR
+
+PATH = CONFIG_DIR / "recent.json"
+KEEP = 50
+_TICKER = re.compile(r"^[A-Z][A-Z0-9.\-]{0,9}$")
+
+
+def load(path=None) -> list[str]:
+    """The remembered symbols, most recent first; [] when there are none."""
+    try:
+        data = json.loads((path or PATH).read_text())
+    except (OSError, ValueError):
+        return []
+    if not isinstance(data, list):
+        return []
+    return [t for t in data if isinstance(t, str) and _TICKER.match(t)][:KEEP]
+
+
+def remember(ticker: str, path=None) -> None:
+    """Put a symbol that was just charted at the front. Ignores anything not
+    shaped like a ticker, so a company name as said is never written."""
+    ticker = (ticker or "").strip().upper()
+    if not _TICKER.match(ticker):
+        return
+    path = path or PATH
+    kept = [ticker] + [t for t in load(path) if t != ticker]
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(kept[:KEEP]))
+        tmp.replace(path)
+    except OSError:
+        pass

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

@@ -2,8 +2,12 @@
 
 launchd sends stderr to ``~/Library/Logs/chartremotely-<service>.log``. The
 line carries only what is needed to tell requests apart: the time, the verb
-(the command's first word, never its arguments), the "Where?" as dictated,
-and the reply when it is an ERR. Never a token, a secret or a picture.
+(the command's first word), the "Where?" as dictated, and the reply when it
+is an ERR. A command's arguments are never logged - except for the free
+``resolve`` and ``scale`` lookups, whose argument is what Siri heard for a
+company or a time frame (``heard=``, at most :data:`HEARD_MAX` characters):
+not sensitive, and the only way to see why a word was not understood.
+Never a token, a secret or a picture.
 
 Stdlib only, like the relay, so it imports where the macOS drivers do not.
 """
@@ -15,6 +19,9 @@ import time
 
 WHERE_MAX = 64
 ERR_MAX = 200
+HEARD_MAX = 60
+#: The verbs whose argument is logged as ``heard=``; see the module doc.
+HEARD_VERBS = frozenset({"resolve", "scale"})
 
 
 def _clean(text: str, limit: int) -> str:
@@ -25,9 +32,12 @@ def _clean(text: str, limit: int) -> str:
 
 def line(source: str, command: str, where: str, reply: str) -> str:
     """The log line for one request (see the module doc)."""
-    verb = _clean((command or "").split(maxsplit=1)[0] if (command or "").strip() else "-", 32)
+    first, _, rest = (command or "").strip().partition(" ")
+    verb = _clean(first or "-", 32)
     parts = [time.strftime("%Y-%m-%dT%H:%M:%S%z"), source, f"verb={verb}",
              f"where={_clean(where or '', WHERE_MAX)!r}"]
+    if first.lower() in HEARD_VERBS:
+        parts.append(f"heard={_clean(rest.strip(), HEARD_MAX)!r}")
     if (reply or "").startswith("ERR"):
         parts.append(f"reply={_clean(reply, ERR_MAX)!r}")
     return " ".join(parts)

{chartremotely-0.2.10 → chartremotely-0.2.12}/chartremotely/resolve.py

@@ -15,14 +15,22 @@ Matching runs in tiers, highest score wins:
      650  the query COVERS the name, plus extra words   ("john deere")
      600  consonant skeletons match                     ("volunteer")
      400  fuzzy, as a last resort
+
+:func:`decide` sits on top: it also scores the words run together ("shop if
+y" is "shopify"), treats share classes of one company as one answer, lets
+the symbols this Mac charted recently settle a near-tie, and - when two
+different companies are still too close to call - returns both, so the
+reply can ask "Did you mean ...?" instead of guessing. A confident wrong
+ticker is worse than a question.
 """
 
 from __future__ import annotations
 
 import difflib
 import re
+from dataclasses import dataclass, field
 
-__all__ = ["candidates", "normalize", "phonetic", "resolve", "spelled"]
+__all__ = ["Decision", "candidates", "decide", "normalize", "phonetic", "resolve", "spelled"]
 
 # Corporate furniture, stripped from both sides before comparison. "and"
 # is here because "&" normalises to it, so DEERE & CO reduces to "deere".
@@ -58,6 +66,8 @@ ALIASES = {
     "callalon": "QCOM",     # nasal "Qualcomm"
     "ge aerospace": "GE",   # still filed as GENERAL ELECTRIC CO
     "ge aviation": "GE",
+    "google": "GOOGL",      # filed as Alphabet Inc.
+    "facebook": "META",     # filed as Meta Platforms
 }
 
 # Soundex-style consonant coding: vowels carry almost no information in a
@@ -85,6 +95,16 @@ MIN_PREFIX = 4
 MIN_FUZZY = 5
 FUZZY_FLOOR = 0.82
 NAME_COVERAGE = 0.6       # how much of the company name the query must cover
+#: Two different companies scoring within this of each other is a question.
+MARGIN = 10.0
+#: A symbol charted recently wins when it scores within this of the best -
+#: unless the best is the ticker itself or the exact company name.
+PRIOR_MARGIN = 25.0
+CERTAIN = 900.0
+#: A close-scoring name far less prominent than the best one (by its place
+#: in the SEC file) is no real contender: "robinhood" is HOOD, not a fund.
+def _contends(rank: int, top_rank: int) -> bool:
+    return rank <= 4 * top_rank + 400
 
 
 def normalize(text: str) -> str:
@@ -195,13 +215,85 @@ def candidates(query: str, rows: list[dict]) -> list[tuple[float, str, str]]:
     return out
 
 
-def resolve(query: str, rows: list[dict]) -> str | None:
-    """Best ticker for a spoken query, or None when nothing is convincing."""
+@dataclass(frozen=True)
+class Decision:
+    """What a spoken company name came to.
+
+    ``ticker`` is set only when the answer is clear. ``options`` holds the
+    (ticker, spoken name) pairs too close to call - never set together with
+    ``ticker``. Neither set means nothing matched.
+    """
+
+    ticker: str | None = None
+    options: list[tuple[str, str]] = field(default_factory=list)
+
+    def question(self) -> str:
+        """'Did you mean PLTR (Palantir Technologies) or FLUT (Flutter Entertainment)?'"""
+        said = [f"{t} ({n})" for t, n in self.options]
+        return "Did you mean " + ", ".join(said[:-1]) + " or " + said[-1] + "?"
+
+
+def spoken_name(name: str) -> str:
+    """'PALANTIR TECHNOLOGIES INC.' -> 'Palantir Technologies' (three words at most)."""
+    words = strip_suffixes(normalize(name)).split()[:3]
+    return " ".join(words).title()
+
+
+def _ranked(query: str, rows: list[dict]) -> list[tuple[float, str, str]]:
+    """Candidates for the query and for its words run together, best per ticker."""
+    best: dict[str, tuple[float, str, str]] = {}
+    forms = [query]
+    # "and" stays in: "pal and tear" run together sounds like Palantir. Words
+    # that are all filler are still refused, run together or not.
+    words = normalize(query).split()
+    if len(words) > 1 and set(words) - STOPWORDS:
+        forms.append("".join(words))
+    for form in forms:
+        for cand in candidates(form, rows):
+            if cand[1] not in best or cand[0] > best[cand[1]][0]:
+                best[cand[1]] = cand
+    return sorted(best.values(), key=lambda c: -c[0])
+
+
+def decide(query: str, rows: list[dict], recent: list[str] | tuple = ()) -> Decision:
+    """The ticker for a spoken name, the options to ask about, or nothing.
+
+    ``recent`` is the symbols this Mac charted lately, most recent first;
+    it only ever settles a near-tie (see :data:`PRIOR_MARGIN`).
+    """
     letters = spelled(query)
     if letters and any(r["t"] == letters for r in rows):
-        return letters
+        return Decision(letters)
     direct = ALIASES.get(normalize(query))
     if direct:
-        return direct
-    ranked = candidates(query, rows)
-    return ranked[0][1] if ranked else None
+        return Decision(direct)
+    ranks = {r["t"]: r.get("r", 0) for r in rows}
+    ranked = _ranked(query, rows)
+    if not ranked:
+        return Decision()
+    # One company, many share classes (F, F-PB, F-PC...): one answer, the best.
+    companies: list[tuple[float, str, str]] = []
+    seen: set[str] = set()
+    for cand in ranked:
+        key = strip_suffixes(normalize(cand[2]))
+        if key not in seen:
+            seen.add(key)
+            companies.append(cand)
+    top = companies[0][0]
+    order = {t.upper(): i for i, t in reversed(list(enumerate(recent)))}
+    if top < CERTAIN:
+        known = [c for c in companies if c[1] in order and top - c[0] <= PRIOR_MARGIN]
+        if known:
+            return Decision(min(known, key=lambda c: order[c[1]])[1])
+    top_rank = ranks.get(companies[0][1], 0)
+    close = [c for c in companies if top - c[0] <= MARGIN
+             and (c is companies[0] or _contends(ranks.get(c[1], 0), top_rank))]
+    if len(close) == 1:
+        return Decision(close[0][1])
+    return Decision(options=[(t, spoken_name(n)) for _, t, n in close[:3]])
+
+
+def resolve(query: str, rows: list[dict], recent: list[str] | tuple = ()) -> str | None:
+    """Best ticker for a spoken query, or None when nothing is convincing or
+    the answer is too close to call (see :func:`decide`)."""
+    return decide(query, rows, recent).ticker