cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/formulas.py

@@ -0,0 +1,82 @@
+from .mathtext import frac_part as F, sub, sup
+
+FORMULAS = [
+    {
+        "name": "First Order Rate Constant",
+        "tag": "Kinetics",
+        "formula": ["k = ", F("2.303", "t"), f"  log(R{sub(0)}/R)"],
+        "meaning": "Gives the rate constant of a first order reaction from concentrations at two times.",
+        "variables": "k = rate constant, t = time elapsed, R0 = initial concentration, R = concentration at time t",
+        "units": f"k -> time{sup(-1)} (e.g. s{sup(-1)}, min{sup(-1)})",
+        "conditions": "Valid only for reactions that are first order overall.",
+        "mistakes": "Forgetting the 2.303 factor when converting ln to log10; mixing up R0 and R inside the log.",
+        "trick": "log(R0/R) is always positive since R0 > R for a forward reaction — a negative result signals swapped values.",
+        "memory": "\"2.303 over t, log the ratio\" — say it as one phrase.",
+        "example": "R0 = 0.8 M, R = 0.4 M, t = 20 min -> k = (2.303/20) log(2) = 0.0347 min-1",
+    },
+    {
+        "name": "First Order Half-Life",
+        "tag": "Kinetics",
+        "formula": ["t\u00bd = ", F("0.693", "k")],
+        "meaning": "Time required for concentration to fall to half its initial value; constant for first order reactions.",
+        "variables": "t1/2 = half-life, k = rate constant",
+        "units": "t1/2 -> same time unit used for k-1",
+        "conditions": "Independent of initial concentration — a hallmark of first order kinetics.",
+        "mistakes": "Using this formula for zero or second order reactions, where half-life depends on concentration.",
+        "trick": "0.693 is just ln(2) — recall ln(2) \u2248 0.693 to rebuild the formula instantly.",
+        "memory": "\"Half-life never lies\" for first order — always the same value.",
+        "example": "k = 0.0347 min-1 -> t1/2 = 0.693/0.0347 \u2248 20 min",
+    },
+    {
+        "name": "Zero Order Rate Law",
+        "tag": "Kinetics",
+        "formula": ["k = ", F(f"R{sub(0)} \u2212 R", "t")],
+        "meaning": "Rate constant for a zero order reaction, where rate is independent of concentration.",
+        "variables": "R0 = initial concentration, R = concentration at time t, t = time",
+        "units": f"k -> mol L{sup(-1)} time{sup(-1)}",
+        "conditions": "Applies when reaction rate does not change with reactant concentration (e.g. surface-catalysed reactions).",
+        "mistakes": "Applying the first-order log formula by mistake; forgetting that k here carries concentration units.",
+        "trick": "Zero order graphs are a straight line of [R] vs t — spot it visually before calculating.",
+        "memory": "\"Zero order, straight decline.\"",
+        "example": "R0 = 1.0 M, R = 0.8 M, t = 20 min -> k = (1.0-0.8)/20 = 0.01 mol L-1 min-1",
+    },
+    {
+        "name": "Second Order Rate Law",
+        "tag": "Kinetics",
+        "formula": [F("1", "R"), " = ", F("1", f"R{sub(0)}"), " + kt"],
+        "meaning": "Relates concentration to time for a second order reaction.",
+        "variables": "R0 = initial concentration, R = concentration at time t, k = rate constant, t = time",
+        "units": f"k -> L mol{sup(-1)} time{sup(-1)}",
+        "conditions": "Applies when rate depends on the square of one reactant's concentration (or product of two reactants).",
+        "mistakes": "Forgetting to invert both concentrations before subtracting; unit mismatch with first-order k.",
+        "trick": "A straight line of 1/[R] vs t confirms second order behaviour.",
+        "memory": "\"Flip it, then add kt.\"",
+        "example": "R0 = 1 M, k = 0.02 L mol-1 min-1, t = 20 min -> 1/R = 1 + 0.4 = 1.4 -> R \u2248 0.714 M",
+    },
+    {
+        "name": "Arrhenius Equation",
+        "tag": "Kinetics",
+        "formula": ["k = A e", "^(\u2212Ea/RT)"],
+        "meaning": "Describes how rate constant depends on temperature and activation energy.",
+        "variables": "k = rate constant, A = pre-exponential factor, Ea = activation energy, R = gas constant, T = temperature (K)",
+        "units": "Ea -> J/mol (use R = 8.314 J/mol/K) or kJ/mol (use R = 0.008314 kJ/mol/K)",
+        "conditions": "Temperature must be in Kelvin; assumes Ea is constant over the range considered.",
+        "mistakes": "Mixing kJ and J units for Ea and R; using \u00b0C instead of Kelvin.",
+        "trick": f"For two temperatures, skip solving for A — use ln(k{sub(2)}/k{sub(1)}) = \u2212Ea/R (1/T{sub(2)} \u2212 1/T{sub(1)}).",
+        "memory": "\"Bigger T, bigger k — always increasing.\"",
+        "example": "Ea = 75 kJ/mol, k1 at 300 K, T2 = 310 K -> k2 > k1, computed via the two-point form.",
+    },
+    {
+        "name": "Mole-Mass Relation",
+        "tag": "Mole Concept",
+        "formula": ["n = ", F("m", "M")],
+        "meaning": "Converts a given mass of a substance into number of moles.",
+        "variables": "n = number of moles, m = given mass, M = molar mass",
+        "units": "n -> mol, m -> g, M -> g/mol",
+        "conditions": "M must correspond to the correct chemical formula (watch for hydrates, ions).",
+        "mistakes": "Using atomic mass instead of molar mass for compounds; forgetting water of crystallisation in hydrates.",
+        "trick": "Sanity check: multiply n x M and confirm it returns the original mass.",
+        "memory": "\"Moles = mass over molar mass — m over M.\"",
+        "example": "5 g of NaOH (M = 40 g/mol) -> n = 5/40 = 0.125 mol",
+    },
+]

calc_terminal/fs_cache.py

@@ -0,0 +1,121 @@
+"""
+CAT v0.7.9.0 — fs_cache.py: safe, self-invalidating filesystem metadata
+cache (requirement #12 — SMART CACHING).
+
+Caches the expensive-to-rebuild, cheap-to-key results CAT asks for over
+and over inside one agent run:
+
+* directory listings   (keyed by path; invalidated by that directory's
+                        mtime AND by explicit mutation notifications)
+* workspace index      (keyed by root + a cheap signature of the tree)
+
+Correctness rules:
+* NEVER return stale data after a known mutation: every write/rename/
+  delete tool call in agent.py notifies invalidate_path(), and each cache
+  hit re-checks the directory's own mtime first — an external change made
+  outside CAT is picked up automatically.
+* TTL is short (2 s) on purpose: it collapses repeated scans WITHIN one
+  agent step burst without ever serving yesterday's view of the world.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import os
+import threading
+import time
+from typing import Any, Callable, Dict, Optional, Tuple
+
+DEFAULT_TTL = 2.0          # seconds
+MAX_ENTRIES = 256
+
+_lock = threading.Lock()
+_store: Dict[str, Tuple[float, Any]] = {}      # key -> (expires_at, value)
+_signatures: Dict[str, Tuple] = {}             # key -> validity signature
+
+
+def _dir_signature(path: str) -> Tuple:
+    """Cheap validity probe: directory mtime (+ its own existence). An
+    external add/remove/update inside the dir changes st_mtime, so the
+    cached listing goes stale immediately."""
+    try:
+        st = os.stat(path)
+        return (st.st_mtime_ns, st.st_size)
+    except OSError:
+        return ("missing",)
+
+
+def get_cached(key: str):
+    with _lock:
+        entry = _store.get(key)
+        if entry is None:
+            return None
+        expires_at, value = entry
+        if expires_at < time.time():
+            _store.pop(key, None)
+            _signatures.pop(key, None)
+            return None
+        return value
+
+
+def put_cached(key: str, value, ttl: float = DEFAULT_TTL,
+               signature: Optional[Tuple] = None) -> None:
+    with _lock:
+        if len(_store) >= MAX_ENTRIES:
+            # Drop the soonest-expiring entries first.
+            for k in sorted(_store, key=lambda k: _store[k][0])[:32]:
+                _store.pop(k, None)
+                _signatures.pop(k, None)
+        _store[key] = (time.time() + max(0.05, ttl), value)
+        if signature is not None:
+            _signatures[key] = signature
+
+
+def valid_signature(key: str, signature: Tuple) -> bool:
+    with _lock:
+        return _signatures.get(key) == signature
+
+
+def invalidate_path(path: str) -> None:
+    """Called by every mutating tool (write/create/delete/rename) so no
+    cached listing can ever outlive a known change. Invalidates the path
+    itself and all cached ancestors (a new file changes the parent's
+    listing too)."""
+    path = os.path.normpath(os.path.abspath(str(path)))
+    with _lock:
+        for key in [k for k in _store if k.startswith("dirls:")]:
+            try:
+                cached_path = key[len("dirls:"):]
+                norm = os.path.normpath(os.path.abspath(cached_path))
+            except Exception:
+                continue
+            if norm == path or path.startswith(norm + os.sep) \
+                    or norm.startswith(path + os.sep):
+                _store.pop(key, None)
+                _signatures.pop(key, None)
+
+
+def clear() -> None:
+    with _lock:
+        _store.clear()
+        _signatures.clear()
+
+
+def cached_dir_listing(path: str, builder: Callable[[], Any],
+                       ttl: float = DEFAULT_TTL):
+    """TTL+mtime-guarded directory listing. `builder` does the real scan;
+    it only runs when there is no fresh, still-valid cached copy."""
+    try:
+        real = os.path.abspath(path)
+    except Exception:
+        return builder()
+    key = "dirls:" + real
+    sig = _dir_signature(real)
+    cached = get_cached(key)
+    if cached is not None and valid_signature(key, sig):
+        return cached
+    value = builder()
+    put_cached(key, value, ttl=ttl, signature=sig)
+    return value

calc_terminal/fs_watcher.py

@@ -0,0 +1,277 @@
+"""
+CAT v0.7.9.0 — fs_watcher.py: real-time filesystem watching for the
+live File Explorer.
+
+Architecture (the whole point of this module):
+
+    REAL FILESYSTEM
+          |
+      watcher (watchdog Observer, or a stdlib snapshot-poll fallback)
+          |
+    debounced filesystem events  ->  callback(set_of_changed_paths)
+          |
+    Workspace state manager (ui/app.py bridges to the UI thread)
+          |
+    Explorer tree refresh
+
+The callback is ALWAYS invoked on a background thread — it must never
+touch widgets. ui/app.py's `_on_fs_events` marshals the paths back to
+the UI thread with call_from_thread and posts a WorkspaceFilesChanged
+Message, exactly like every other worker-to-UI crossing in this app.
+
+Design notes:
+
+* watchdog's Observer is used when importable (real OS push events on
+  Windows — ReadDirectoryChangesW — plus inotify/FSEvents elsewhere).
+  When it isn't installed, a low-overhead stdlib poller takes over: it
+  walks only the active workspace root every POLL_INTERVAL seconds,
+  compares name/mtime snapshots, and reports only actual differences.
+  That fallback is throttled by construction (one walk per interval,
+  nothing between ticks) — never a busy loop.
+* Events are debounced: bursts of related changes (a save writing a
+  temp file then renaming it over the target; `git checkout` touching
+  hundreds of files) coalesce into one callback ~DEBOUNCE seconds after
+  the last raw event, so the Explorer reloads once, not N times.
+* One watcher instance per app. `start(root)` stops whatever root was
+  being watched before (new workspace => stop old watcher => start new
+  watcher), so the Explorer can never observe a stale folder.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import os
+import threading
+
+try:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler as _WdHandler
+    WATCHDOG_AVAILABLE = True
+except Exception:
+    WATCHDOG_AVAILABLE = False
+    Observer = None
+
+    class _WdHandler:  # stand-in so the class body below still parses
+        pass
+
+
+class WorkspaceWatcher:
+    """Watches one workspace root and reports debounced change sets.
+
+    Parameters
+    ----------
+    callback : callable(set[str])
+        Invoked with the set of changed absolute paths. Always called
+        from a background thread (the Observer's emitter thread or the
+        fallback poller thread). Exceptions raised inside it must be
+        its own responsibility.
+    """
+
+    DEBOUNCE = 0.35          # seconds of quiet before flushing a burst
+    POLL_INTERVAL = 2.0      # fallback poll cadence (no watchdog)
+
+    def __init__(self, callback):
+        self._callback = callback
+        self._root = None
+        self._lock = threading.Lock()
+        self._pending = set()
+        self._debounce_timer = None
+        self._observer = None
+        self._poll_thread = None
+        self._poll_stop = threading.Event()
+        self._snapshot = {}
+
+    # ------------------------------------------------------------ start --
+    def start(self, root):
+        """(Re)points the watcher at `root`. Stops the previous watch
+        first, so switching workspaces never leaves an old Observer (or
+        old poller) running against a folder that is no longer open."""
+        root = os.path.abspath(os.path.expanduser(root))
+        if not os.path.isdir(root):
+            return False
+        self.stop()
+        with self._lock:
+            self._root = root
+            self._pending.clear()
+        if WATCHDOG_AVAILABLE:
+            return self._start_observer(root)
+        return self._start_poller(root)
+
+    def _start_observer(self, root):
+        try:
+            observer = Observer(timeout=0.5)
+            observer.daemon = True
+            handler = _Handler(self)
+            # watch() on the root itself; recursive covers subfolders.
+            # Windows/ReadDirectoryChangesW delivers create/delete/
+            # rename/modify for everything below root.
+            observer.schedule(handler, root, recursive=True)
+            observer.start()
+            self._observer = observer
+            return True
+        except Exception:
+            # Watchdog exists but the platform refused the watch (rare
+            # — e.g. a drive gone mid-call): fall back to polling.
+            self._observer = None
+            return self._start_poller(root)
+
+    def _start_poller(self, root):
+        self._poll_stop.clear()
+        try:
+            self._snapshot = self._scan(root)
+        except Exception:
+            self._snapshot = {}
+        thread = threading.Thread(
+            target=self._poll_loop, args=(root,),
+            name="cat-fs-poll", daemon=True)
+        thread.start()
+        self._poll_thread = thread
+        return True
+
+    # ------------------------------------------------------------- stop --
+    def stop(self):
+        """Fully tears down whichever mechanism is running. Safe to call
+        twice / when never started."""
+        with self._lock:
+            self._root = None
+            self._cancel_debounce_locked()
+        observer = self._observer
+        self._observer = None
+        if observer is not None:
+            try:
+                observer.stop()
+                observer.join(timeout=2.0)
+            except Exception:
+                pass
+        self._poll_stop.set()
+        thread = self._poll_thread
+        self._poll_thread = None
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=2.0)
+        with self._lock:
+            self._pending.clear()
+        self._snapshot = {}
+
+    @property
+    def root(self):
+        return self._root
+
+    @property
+    def active(self):
+        return self._observer is not None or self._poll_thread is not None
+
+    @property
+    def event_based(self):
+        """True when backed by real OS events (watchdog); False when the
+        throttled poll fallback is in charge."""
+        return self._observer is not None
+
+    # ------------------------------------------------- event collection --
+    def report(self, path):
+        """Thread-safe event intake. Called by the watchdog handler for
+        every raw filesystem event (and usable directly for explicit
+        internal TOOL_FILE_* notifications). Bursts are coalesced and
+        flushed once the stream goes quiet for DEBOUNCE seconds."""
+        if path:
+            with self._lock:
+                if self._root is None:
+                    return
+                self._pending.add(os.path.abspath(path))
+                self._cancel_debounce_locked()
+                timer = threading.Timer(self.DEBOUNCE, self._flush)
+                timer.daemon = True
+                timer.start()
+                self._debounce_timer = timer
+
+    def _cancel_debounce_locked(self):
+        timer = self._debounce_timer
+        self._debounce_timer = None
+        if timer is not None:
+            timer.cancel()
+
+    def _flush(self):
+        with self._lock:
+            batch = self._pending
+            self._pending = set()
+        if batch and self._callback is not None:
+            try:
+                self._callback(batch)
+            except Exception:
+                pass
+
+    # ---------------------------------------------------- poll fallback --
+    def _scan(self, root):
+        """One shallow-everything snapshot: {path: mtime}. Directories
+        get st_mtime too (Windows keeps dir mtimes fresh on content
+        churn), so folder create/delete shows up as a diff without any
+        special handling. Symlinks are never followed."""
+        snap = {}
+        stack = [root]
+        while stack:
+            current = stack.pop()
+            try:
+                snap[current] = os.stat(current).st_mtime
+                with os.scandir(current) as entries:
+                    for entry in entries:
+                        try:
+                            if entry.is_symlink():
+                                continue
+                            if entry.is_dir(follow_symlinks=False):
+                                stack.append(entry.path)
+                            else:
+                                snap[entry.path] = entry.stat().st_mtime
+                        except OSError:
+                            continue
+            except (OSError, PermissionError):
+                continue
+        return snap
+
+    def _poll_loop(self, root):
+        while not self._poll_stop.wait(self.POLL_INTERVAL):
+            if self._root != root:
+                return
+            try:
+                fresh = self._scan(root)
+            except Exception:
+                continue
+            old = self._snapshot
+            changed = {p for p in fresh.keys() ^ old.keys()}
+            for p in fresh.keys() & old.keys():
+                if fresh[p] != old[p]:
+                    changed.add(p)
+            if changed:
+                self._snapshot = fresh
+                for p in list(changed)[:64]:   # cap the burst size
+                    self.report(p)
+            else:
+                # Keep mtimes fresh even when nothing changed, so the
+                # next comparison stays cheap.
+                self._snapshot = fresh
+
+
+class _Handler(_WdHandler):
+    """Watchdog adapter: forwards every interesting event kind into the
+    watcher's debounced intake."""
+
+    def __init__(self, watcher):
+        super().__init__()
+        self._watcher = watcher
+
+    def on_created(self, event):
+        self._emit(event.dest_path or event.src_path)
+
+    def on_deleted(self, event):
+        self._emit(event.src_path)
+
+    def on_modified(self, event):
+        self._emit(event.src_path)
+
+    def on_moved(self, event):
+        self._emit(event.src_path)
+        self._emit(event.dest_path)
+
+    def _emit(self, path):
+        if path:
+            self._watcher.report(path)

calc_terminal/game.py

@@ -0,0 +1,193 @@
+"""
+Element Quiz — a small multiple-choice game bolted onto the same
+premium panel/gradient rendering as the rest of Chemistry Calc
+Terminal, so learning periodic-table facts feels like part of the
+same app instead of a bolted-on mini-game.
+
+Question types are generated from the same ELEMENTS table atomsim.py
+already uses for the live Bohr simulation (Z, symbol, name, shells,
+mass), so there's exactly one source of truth for element data.
+"""
+
+import random
+import time
+
+from . import theme
+from . import sound
+from .atomsim import ELEMENTS
+from .engine import WIDTH
+LETTERS = ["A", "B", "C", "D"]
+START_LIVES = 3
+
+
+def _shells_str(shells):
+    return "-".join(str(s) for s in shells)
+
+
+def _distractor_pool(exclude_z):
+    return [z for z in ELEMENTS if z != exclude_z]
+
+
+def _make_options(correct, pool_values, n=4):
+    others = random.sample([v for v in pool_values if v != correct], min(n - 1, len(pool_values) - 1))
+    options = others + [correct]
+    random.shuffle(options)
+    return options
+
+
+def make_question(difficulty=1):
+    """Build one multiple-choice question dict:
+    {prompt, options: [...], correct_index, explain}"""
+    z = random.choice(list(ELEMENTS.keys()))
+    sym, name, shells, mass = ELEMENTS[z]
+    qtype = random.choice([
+        "symbol_from_name", "name_from_symbol", "z_from_name",
+        "name_from_z", "shells_from_name", "mass_from_name",
+    ])
+
+    if qtype == "symbol_from_name":
+        prompt = f"What is the chemical symbol for {theme.text(name, bold=True)}?"
+        correct = sym
+        pool = [ELEMENTS[k][0] for k in ELEMENTS]
+        explain = f"{name} \u2192 {sym} (Z={z})"
+    elif qtype == "name_from_symbol":
+        prompt = f"Which element has the symbol {theme.cyan(sym, bold=True)}?"
+        correct = name
+        pool = [ELEMENTS[k][1] for k in ELEMENTS]
+        explain = f"{sym} \u2192 {name} (Z={z})"
+    elif qtype == "z_from_name":
+        prompt = f"What is the atomic number of {theme.text(name, bold=True)}?"
+        correct = str(z)
+        pool = [str(k) for k in ELEMENTS]
+        explain = f"{name} has {z} protons \u2192 Z = {z}"
+    elif qtype == "name_from_z":
+        prompt = f"Which element has atomic number {theme.orange(str(z), bold=True)}?"
+        correct = name
+        pool = [ELEMENTS[k][1] for k in ELEMENTS]
+        explain = f"Z={z} \u2192 {name} ({sym})"
+    elif qtype == "shells_from_name":
+        prompt = f"What is the electron shell structure (K-L-M...) of {theme.text(name, bold=True)}?"
+        correct = _shells_str(shells)
+        pool_z = random.sample(list(ELEMENTS.keys()), min(12, len(ELEMENTS)))
+        pool = [_shells_str(ELEMENTS[k][2]) for k in pool_z]
+        explain = f"{name} ({sym}, Z={z}) \u2192 {_shells_str(shells)}"
+    else:  # mass_from_name
+        prompt = f"What is the approximate atomic mass of {theme.text(name, bold=True)}?"
+        correct = str(mass)
+        pool = [str(ELEMENTS[k][3]) for k in ELEMENTS]
+        explain = f"{name} ({sym}) \u2248 {mass} u"
+
+    options = _make_options(correct, pool)
+    if correct not in options:
+        options[-1] = correct
+        random.shuffle(options)
+    correct_index = options.index(correct)
+    return {"prompt": prompt, "options": options, "correct_index": correct_index, "explain": explain}
+
+
+def _hearts(lives):
+    return theme.red("\u2665 " * lives, bold=True) + theme.faint("\u2661 " * (START_LIVES - lives))
+
+
+def _streak_badge(streak):
+    if streak >= 8:
+        return theme.gradient(f"\U0001f525 x{streak} ON FIRE", theme.ORANGE, theme.RED, bold=True)
+    if streak >= 4:
+        return theme.orange(f"\U0001f525 x{streak} streak", bold=True)
+    if streak >= 1:
+        return theme.dim(f"streak x{streak}")
+    return theme.faint("streak x0")
+
+
+def _grade(score):
+    if score >= 900:
+        return "S", theme.gradient("S \u2014 PERIODIC LEGEND", theme.CYAN, theme.PURPLE, bold=True)
+    if score >= 600:
+        return "A", theme.green("A \u2014 Sharp chemist", bold=True)
+    if score >= 350:
+        return "B", theme.cyan("B \u2014 Solid grasp", bold=True)
+    if score >= 150:
+        return "C", theme.orange("C \u2014 Getting there", bold=True)
+    return "D", theme.faint("D \u2014 Back to the formula library")
+
+
+def run_game(app):
+    theme.clear_screen()
+    print()
+    print(theme.panel([
+        theme.gradient("\u2697  ELEMENT QUIZ  \u2697", theme.CYAN, theme.PURPLE, bold=True),
+        "",
+        theme.dim("Multiple choice \u2014 symbols, names, atomic numbers, shells & mass."),
+        theme.dim(f"You have {START_LIVES} lives. Answer fast for a speed bonus."),
+        theme.dim("Type a letter (A-D) to answer, or /quit to stop anytime."),
+    ], title="game", color=theme.PURPLE, width=WIDTH, title_gradient=(theme.CYAN, theme.PURPLE)))
+
+    score = 0
+    streak = 0
+    best_streak_this_run = 0
+    lives = START_LIVES
+    qn = 0
+
+    while lives > 0:
+        qn += 1
+        q = make_question()
+        print()
+        header = (theme.faint(f"Q{qn}") + "   " + _hearts(lives) + "   " +
+                  theme.dim(f"score {score}") + "   " + _streak_badge(streak))
+        print("  " + header)
+        print(theme.panel(
+            [q["prompt"], ""] + [f"  {theme.cyan(LETTERS[i])}. {opt}" for i, opt in enumerate(q["options"])],
+            title=f"question {qn}", color=theme.CYAN, width=WIDTH,
+        ))
+        start = time.time()
+        try:
+            raw = input(theme.dim("  answer \u25b8 ")).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        elapsed = time.time() - start
+        low = raw.strip().lower()
+        if low in ("/quit", "/back", "/exit", "quit"):
+            break
+
+        pick = None
+        if low and low[0].upper() in LETTERS:
+            pick = LETTERS.index(low[0].upper())
+
+        if pick == q["correct_index"]:
+            speed_bonus = 40 if elapsed < 3 else (20 if elapsed < 6 else 0)
+            base = 60
+            streak += 1
+            best_streak_this_run = max(best_streak_this_run, streak)
+            gained = base + speed_bonus + streak * 5
+            score += gained
+            sound.play("success")
+            tag = " \u26a1 speed bonus!" if speed_bonus == 40 else ""
+            print("  " + theme.green(f"\u2713 Correct! +{gained}{tag}", bold=True))
+            print("  " + theme.dim(q["explain"]))
+        else:
+            lives -= 1
+            streak = 0
+            sound.play("error")
+            correct_letter = LETTERS[q["correct_index"]]
+            print("  " + theme.red(f"\u2717 Not quite \u2014 correct answer was {correct_letter}.", bold=True))
+            print("  " + theme.dim(q["explain"]))
+            if lives == 0:
+                print("  " + theme.orange("Out of lives!", bold=True))
+
+    app.game_high_score = max(app.game_high_score, score)
+    app.game_best_streak = max(app.game_best_streak, best_streak_this_run)
+    _, grade_line = _grade(score)
+
+    print()
+    print(theme.panel([
+        theme.gradient("ROUND OVER", theme.PURPLE, theme.CYAN, bold=True),
+        "",
+        theme.text(f"Final score: {score}", bold=True),
+        theme.dim(f"Best streak this round: {best_streak_this_run}"),
+        theme.dim(f"Session high score: {app.game_high_score}  \u00b7  Session best streak: {app.game_best_streak}"),
+        "",
+        grade_line,
+    ], title="results", color=theme.PURPLE, width=WIDTH, title_gradient=(theme.PURPLE, theme.CYAN)))
+    print()
+    input(theme.faint("  Press Enter to return home\u2026"))

calc_terminal/gen1.py

@@ -0,0 +1,5 @@
+import os, sys
+B=os.path.dirname(os.path.abspath(__file__))
+def W(n,c):
+ with open(os.path.join(B,n),'w',encoding='utf-8') as f: f.write(c)
+ print(f"Wrote {n}")