chartremotely 0.2.11__tar.gz → 0.2.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.11
+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.11 → 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.11 → 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/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.11 → 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.11 → 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

chartremotely-0.2.12/chartremotely/scales.py

@@ -0,0 +1,188 @@
+"""Spoken time-frame vocabulary. Pure logic, no macOS dependency.
+
+Kept apart from the driver so it can be imported anywhere - by CI on Linux,
+and by the operator, which needs to validate a spoken phrase before it has
+any agent to send it to.
+
+The mnemonics are chosen for phonetic distance rather than literal
+accuracy. Digits are the worst thing to say to a recogniser: "fifteen" and
+"fifty" collide, "one" and "won" collide. None of these ten do.
+"""
+
+from __future__ import annotations
+
+import re
+
+MNEMONIC = {
+    "1d1m": "minute", "5d5m": "scalp", "5d15m": "quarter", "10d30m": "half",
+    "20d1h": "hourly", "180d4h": "swing", "1y1d": "daily", "3yw": "weekly",
+    "1d133t": "ticks", "1d10t": "micro",
+}
+
+ALIAS = {
+    "minute": "1d1m", "scalp": "5d5m", "quarter": "5d15m", "half": "10d30m",
+    "hourly": "20d1h", "swing": "180d4h", "daily": "1y1d", "weekly": "3yw",
+    "ticks": "1d133t", "micro": "1d10t",
+    # variants people actually say
+    "tick": "1d133t", "ten tick": "1d10t", "quarter hour": "5d15m",
+    "a quarter hour": "5d15m", "quarter of an hour": "5d15m",
+    "a quarter of an hour": "5d15m",
+    "half hour": "10d30m", "half an hour": "10d30m", "half a hour": "10d30m",
+    "hour": "20d1h", "an hour": "20d1h", "a hour": "20d1h",
+    "day": "1y1d", "a day": "1y1d", "week": "3yw", "a week": "3yw",
+    "a minute": "1d1m", "intraday": "1d1m", "swing trade": "180d4h",
+}
+
+#: A preset by its bar size alone: "thirty minutes" canon's to "30m", which is
+#: no preset's full code, but it is exactly one preset's bar.
+BAR = {
+    "1m": "1d1m", "5m": "5d5m", "15m": "5d15m", "30m": "10d30m",
+    "1h": "20d1h", "60m": "20d1h", "4h": "180d4h", "240m": "180d4h",
+    "1d": "1y1d", "1w": "3yw", "w": "3yw", "133t": "1d133t", "10t": "1d10t",
+}
+
+#: Words said around a scale that name no scale: "at half scale", "the daily chart".
+FILLER = {"at", "on", "the", "scale", "time", "frame", "timeframe", "chart", "bars",
+          "bar", "candles", "candle", "please", "use", "make", "it", "set", "to"}
+
+AS_IS = {"as is", "as-is", "asis", "same", "leave it", "unchanged",
+         "no change", "keep it", "current", "skip", "none", ""}
+
+_WORDS = {"one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6,
+          "seven": 7, "eight": 8, "nine": 9, "ten": 10, "fifteen": 15,
+          "twenty": 20, "thirty": 30, "sixty": 60, "ninety": 90}
+_UNIT = {"d": "d", "day": "d", "days": "d", "daily": "d", "y": "y",
+         "year": "y", "years": "y", "w": "w", "week": "w", "weekly": "w",
+         "weeks": "w", "m": "m", "min": "m", "minute": "m", "minutes": "m",
+         "h": "h", "hour": "h", "hours": "h", "t": "t", "tick": "t",
+         "ticks": "t"}
+
+
+def canon(text: str) -> str:
+    """'5 D : 5m' and 'five day five minute' both give '5d5m'.
+
+    Returns "" when nothing parses. Callers MUST treat that as a refusal:
+    every string ends with "", so a loose endswith match against menu
+    labels would otherwise select whichever preset came first.
+    """
+    s = re.sub(r"[^a-z0-9 ]", " ", text.lower().replace(":", " ").replace("/", " "))
+    for word, n in _WORDS.items():
+        s = re.sub(rf"\b{word}\b", str(n), s)
+    s = re.sub(r"(\d)\s*([a-z])", r"\1\2", s)
+    out = []
+    for token in s.split():
+        m = re.match(r"^(\d+)([a-z]+)$", token)
+        if m and m.group(2) in _UNIT:
+            out.append(m.group(1) + _UNIT[m.group(2)])
+        elif token in _UNIT and out:
+            out.append(_UNIT[token])
+    return "".join(out)
+
+
+#: Every word a spoken scale can be made of. A span of an utterance names a
+#: scale only when all its words are these, so "apple one day" is never
+#: read as "one day" with "apple" ignored.
+SCALE_WORDS = ({w for phrase in ALIAS for w in phrase.split()} | set(_WORDS) | set(_UNIT)
+               | FILLER | {"an", "of"})
+
+
+def is_scale_word(word: str) -> bool:
+    """True for a word :func:`preset` could use: see :data:`SCALE_WORDS`."""
+    return word in SCALE_WORDS or bool(re.fullmatch(r"\d+[a-z]*(\d+[a-z]*)*", word))
+
+
+def _words(phrase: str) -> str:
+    return " ".join(re.sub(r"[^a-z0-9 ]", " ", phrase.lower().replace("-", " ")).split())
+
+
+def preset(phrase: str) -> str | None:
+    """The preset code a phrase names exactly, or None. No guessing.
+
+    A mnemonic or an alias ("half an hour"), a full code ("10 D 30m"), or a
+    bar size alone ("thirty minutes", "4h", "one day"), with filler such as
+    "at ... scale" ignored.
+    """
+    said = _words(phrase)
+    bare = " ".join(w for w in said.split() if w not in FILLER)
+    for form in (said, bare):
+        if form in ALIAS:
+            return ALIAS[form]
+        if form.replace(" ", "") in MNEMONIC:
+            return form.replace(" ", "")
+    code = canon(bare)
+    if code in MNEMONIC:
+        return code
+    bar = re.search(r"(\d*[a-z])$", code)
+    if bar and re.fullmatch(r"\d*[a-z]", code):
+        return BAR.get(bar.group(1))
+    return None
+
+
+def sound_key(word: str) -> str:
+    """A deliberately crude phonetic key for one word.
+
+    ph/gh/v sound as f, c/k/q as k; after the first letter the vowels and
+    h/w/y go; repeats collapse. "half", "halve", "haff" and "alpha" all land
+    within one edit of "hlf".
+    """
+    w = re.sub(r"[^a-z]", "", word.lower()).replace("ph", "f").replace("gh", "f")
+    w = w.translate(str.maketrans("vcq", "fkk"))
+    if not w:
+        return ""
+    out = [w[0]]
+    for ch in w[1:]:
+        if ch in "aeiouhwy" or ch == out[-1]:
+            continue
+        out.append(ch)
+    return "".join(out)
+
+
+def _distance(a: str, b: str) -> int:
+    prev = list(range(len(b) + 1))
+    for i, ca in enumerate(a, 1):
+        cur = [i]
+        for j, cb in enumerate(b, 1):
+            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
+        prev = cur
+    return prev[-1]
+
+
+KEYS = {sound_key(word): word for word in MNEMONIC.values()}
+
+
+def sounds_like(word: str) -> str | None:
+    """The one mnemonic a mis-heard word is within an edit of, else None.
+
+    Two candidates within reach is a refusal, not a coin toss: "hal" is one
+    edit from half, hourly and daily, so it names none of them.
+    """
+    if not word.isalpha():
+        return None
+    key = sound_key(word)
+    if len(key) < 2:
+        return None
+    near = {mn for k, mn in KEYS.items() if _distance(key, k) <= 1}
+    return near.pop() if len(near) == 1 else None
+
+
+def to_code(phrase: str) -> str:
+    """The preset code for a phrase, else its raw canon() (possibly "")."""
+    return preset(phrase) or canon(phrase)
+
+
+def mnemonic_for(phrase: str) -> str | None:
+    """The word we say back, or None if the phrase names no preset.
+
+    Exact first (:func:`preset`); a single mis-heard word falls back to
+    :func:`sounds_like`.
+    """
+    code = preset(phrase)
+    if code:
+        return MNEMONIC[code]
+    words = [w for w in _words(phrase).split() if w not in FILLER]
+    return sounds_like(words[0]) if len(words) == 1 else None
+
+
+def spoken_options() -> str:
+    """What to read aloud when someone says something unrecognised."""
+    return ", ".join(MNEMONIC.values())