typefaster-cli 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

typefaster/__init__.py

@@ -1,3 +1,3 @@
 """TYPEFASTER-CLI — a terminal-first typing game."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"

typefaster/domain/drills.py

@@ -0,0 +1,39 @@
+"""Adaptive drill generation — assemble practice text biased toward weak keys.
+
+Pure and deterministic (the word list and RNG are injected). The service layer
+supplies words from the quote corpus.
+"""
+
+from __future__ import annotations
+
+import random
+
+
+def build_drill(
+    weak_keys: list[str],
+    words: list[str],
+    *,
+    length: int = 30,
+    rng: random.Random | None = None,
+) -> str:
+    """Return a space-joined drill of ``length`` words, weighted so words
+    containing the player's weak keys appear more often. Falls back to a plain
+    random sample when there are no weak keys or no matching words."""
+    rng = rng or random.Random()
+    clean = [w.lower() for w in words if w.isalpha()]
+    if not clean:
+        raise ValueError("no words available to build a drill")
+
+    weak = {c.lower() for c in weak_keys if c.strip()}  # ignore the space key
+    if not weak:
+        return " ".join(rng.choices(clean, k=length))
+
+    # Weight each word by how many distinct weak keys it exercises.
+    scored = [(w, sum(1 for ch in set(w) if ch in weak)) for w in clean]
+    weighted = [(w, s) for w, s in scored if s > 0]
+    if not weighted:
+        weighted = [(w, 1) for w in clean]
+
+    population = [w for w, _ in weighted]
+    weights = [s for _, s in weighted]
+    return " ".join(rng.choices(population, weights=weights, k=length))

typefaster/domain/keyboard.py

@@ -0,0 +1,74 @@
+"""Static QWERTY touch-typing model — which finger reaches each key and how.
+
+Pure reference data (no I/O), used by the typing coach to give finger-position
+guidance and to lay out the per-key heatmap. Keyed by the lowercase character,
+matching how ``TypingEngine`` records key stats.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Visual rows for the heatmap, left-to-right, top-to-bottom.
+ROWS: tuple[str, ...] = ("qwertyuiop", "asdfghjkl", "zxcvbnm")
+
+# Finger assignment for the standard touch-typing layout.
+_FINGER: dict[str, str] = {
+    **dict.fromkeys("qaz", "left pinky"),
+    **dict.fromkeys("wsx", "left ring"),
+    **dict.fromkeys("edc", "left middle"),
+    **dict.fromkeys("rfvtgb", "left index"),
+    **dict.fromkeys("yhnujm", "right index"),
+    **dict.fromkeys("ik,", "right middle"),
+    **dict.fromkeys("ol.", "right ring"),
+    **dict.fromkeys("p;/", "right pinky"),
+    " ": "thumb",
+}
+
+# The resting (home-row) key for each finger.
+_HOME: dict[str, str] = {
+    "left pinky": "a",
+    "left ring": "s",
+    "left middle": "d",
+    "left index": "f",
+    "right index": "j",
+    "right middle": "k",
+    "right ring": "l",
+    "right pinky": ";",
+    "thumb": "space",
+}
+
+HOME_ROW: frozenset[str] = frozenset("asdfjkl;")
+
+
+@dataclass(frozen=True, slots=True)
+class KeyInfo:
+    finger: str
+    home_key: str
+    tip: str
+
+
+def key_info(ch: str) -> KeyInfo | None:
+    """Finger/home/tip for a single key, or None if it's not on the model
+    (e.g. digits or symbols we don't coach)."""
+    ch = ch.lower()
+    finger = _FINGER.get(ch)
+    if finger is None:
+        return None
+    home = _HOME[finger]
+    if ch == " ":
+        tip = "tap with your thumb"
+    elif ch in HOME_ROW:
+        tip = f"home row — rest your {finger} here"
+    elif _row_of(ch) == 0:
+        tip = f"reach up from {home.upper()} with your {finger}"
+    else:
+        tip = f"reach down from {home.upper()} with your {finger}"
+    return KeyInfo(finger=finger, home_key=home, tip=tip)
+
+
+def _row_of(ch: str) -> int:
+    for i, row in enumerate(ROWS):
+        if ch in row:
+            return i
+    return 1  # default to home row

typefaster/domain/models.py

@@ -135,6 +135,8 @@ class RaceResult:
     # Set when the run is implausible (paste/auto-input) — not recorded.
     suspicious: bool = False
     flags: tuple[str, ...] = ()
+    # Per-key (attempts, misses), folded by case — feeds the typing coach.
+    key_stats: dict[str, tuple[int, int]] = field(default_factory=dict)
 
     @property
     def completed(self) -> bool:

typefaster/domain/text_modifiers.py

@@ -0,0 +1,34 @@
+"""MonkeyType-style text modifiers — pure transforms applied to race text.
+
+These reshape the *target text* a player types (e.g. strip everything down to
+lowercase words) without touching the original quote that gets persisted. Kept
+dependency-free and deterministic so they're trivially unit-testable.
+"""
+
+from __future__ import annotations
+
+import re
+
+_NON_WORD = re.compile(r"[^A-Za-z ]+")
+_WHITESPACE = re.compile(r"\s+")
+
+
+def apply_modifiers(text: str, *, lowercase: bool, words_only: bool) -> str:
+    """Apply the active modifiers to ``text``.
+
+    - ``words_only`` keeps only ``[a-z]`` and single spaces (implies lowercase).
+    - ``lowercase`` (when words_only is off) just lowercases.
+
+    Never returns an empty string: if a transform would empty the text (e.g. a
+    quote made entirely of digits/punctuation), the original is returned, since
+    ``TypingEngine`` rejects an empty target.
+    """
+    out = text
+    if words_only:
+        out = _WHITESPACE.sub(" ", out)  # tabs/newlines become separators first
+        out = _NON_WORD.sub("", out)  # drop punctuation/digits, keep letters + space
+        out = _WHITESPACE.sub(" ", out).strip()  # collapse any doubled spaces
+        out = out.lower()
+    elif lowercase:
+        out = out.lower()
+    return out or text

typefaster/domain/typing_engine.py

@@ -37,6 +37,11 @@ class TypingEngine:
         self._total_keystrokes = 0
         self._correct_keystrokes = 0
 
+        # Per-key (case-folded) attempt/miss counts for the typing coach. These
+        # count every keypress, so a mistake counts even if later corrected.
+        self._key_attempts: dict[str, int] = {}
+        self._key_misses: dict[str, int] = {}
+
         self._timeline: list[ReplayPoint] = [ReplayPoint(0, 0.0)]
         self._last_progress_pct = 0.0
 
@@ -57,6 +62,12 @@ class TypingEngine:
         if is_correct:
             self._correct_keystrokes += 1
 
+        # Track the *expected* key (case-folded) so the coach can rank weak keys.
+        k = expected.lower()
+        self._key_attempts[k] = self._key_attempts.get(k, 0) + 1
+        if not is_correct:
+            self._key_misses[k] = self._key_misses.get(k, 0) + 1
+
         self._record(t_ms)
 
     def backspace(self, t_ms: int) -> None:
@@ -95,6 +106,13 @@ class TypingEngine:
     def correct_keystrokes(self) -> int:
         return self._correct_keystrokes
 
+    @property
+    def key_stats(self) -> dict[str, tuple[int, int]]:
+        """Per-key (attempts, misses), case-folded, for the typing coach."""
+        return {
+            k: (attempts, self._key_misses.get(k, 0)) for k, attempts in self._key_attempts.items()
+        }
+
     @property
     def progress(self) -> float:
         """Completion fraction 0..1 based on cursor position."""
@@ -147,4 +165,5 @@ class TypingEngine:
             timeline=self.timeline,
             ghost_kind=ghost_kind,
             ghost_won=ghost_won,
+            key_stats=self.key_stats,
         )

typefaster/infra/config.py

@@ -20,6 +20,9 @@ class Settings:
     allow_backspace: bool = True
     default_ghost: str = "personal-best"
     sound: bool = False
+    # MonkeyType-style text modifiers (applied to the text you type).
+    lowercase_only: bool = False
+    words_only: bool = False
 
     @classmethod
     def load(cls, path: Path | None = None) -> Settings:

typefaster/infra/migrations.py

@@ -78,6 +78,19 @@ _MIGRATIONS: list[tuple[int, str]] = [
         CREATE INDEX IF NOT EXISTS idx_race_kind_wpm ON race(race_kind, mode_seconds, wpm DESC);
         """,
     ),
+    (
+        3,
+        # Running per-key (case-folded) attempt/miss aggregate for the typing
+        # coach. One row per key; upserted after every race. Local-only.
+        """
+        CREATE TABLE IF NOT EXISTS key_stats (
+            key_char   TEXT PRIMARY KEY,
+            attempts   INTEGER NOT NULL DEFAULT 0,
+            misses     INTEGER NOT NULL DEFAULT 0,
+            updated_at TEXT NOT NULL
+        );
+        """,
+    ),
 ]
 
 

typefaster/infra/quote_loader.py

@@ -42,6 +42,19 @@ def quotes_by_difficulty(difficulty: Difficulty) -> list[Quote]:
     return [q for q in all_quotes() if q.difficulty == difficulty]
 
 
+@lru_cache(maxsize=1)
+def corpus_words() -> tuple[str, ...]:
+    """Distinct lowercase alphabetic words from the quote corpus, for building
+    typing drills. Cached since the corpus is static."""
+    seen: set[str] = set()
+    for quote in all_quotes():
+        for raw in quote.text.split():
+            word = "".join(c for c in raw if c.isalpha()).lower()
+            if 2 <= len(word) <= 12:
+                seen.add(word)
+    return tuple(sorted(seen))
+
+
 def daily_quote(day: date | None = None) -> Quote:
     """Deterministically pick the same quote for everyone on a given UTC day."""
     quotes = all_quotes()

typefaster/infra/repository.py

@@ -44,6 +44,10 @@ class Repository(Protocol):
 
     def list_history(self, limit: int = 20, offset: int = 0) -> list[RaceRecord]: ...
     def count_races(self) -> int: ...
+
+    # per-key stats (typing coach)
+    def get_key_stats(self) -> dict[str, tuple[int, int]]: ...
+    def record_key_stats(self, key_stats: dict[str, tuple[int, int]], updated_at: str) -> None: ...
     def average_wpm_accuracy(self) -> tuple[float, float]: ...
     def best_by_mode(self, kind: RaceKind = ...) -> dict[int, float]: ...
     def best_quote_run(self) -> tuple[float, int] | None: ...
@@ -60,4 +64,5 @@ class Repository(Protocol):
 
     # daily
     def get_or_create_daily(self, day: str, quote: Quote) -> DailyChallenge: ...
+    def daily_days_played(self) -> list[str]: ...
     def daily_leaderboard(self, day: str, limit: int = 20) -> list[RaceRecord]: ...

typefaster/infra/sqlite_repository.py

@@ -107,6 +107,7 @@ class SQLiteRepository:
         with transaction(self._conn):
             self._conn.execute("DELETE FROM race")
             self._conn.execute("DELETE FROM daily_challenge")
+            self._conn.execute("DELETE FROM key_stats")
         self.recompute_profile()
 
     # ── quotes ─────────────────────────────────────────────────────────
@@ -168,10 +169,36 @@ class SQLiteRepository:
                 (race_id, replay_store.serialize(result.timeline)),
             )
             self._bump_profile(result)
+            self._bump_key_stats(result.key_stats, started_at)
             if is_daily:
                 self._bump_daily(started_at[:10], quote_id, result.wpm)
         return race_id
 
+    def _bump_key_stats(self, key_stats: dict[str, tuple[int, int]], updated_at: str) -> None:
+        """Add this race's per-key attempts/misses into the running aggregate."""
+        for key_char, (attempts, misses) in key_stats.items():
+            self._conn.execute(
+                """
+                INSERT INTO key_stats(key_char, attempts, misses, updated_at)
+                VALUES(?, ?, ?, ?)
+                ON CONFLICT(key_char) DO UPDATE SET
+                  attempts   = attempts + excluded.attempts,
+                  misses     = misses + excluded.misses,
+                  updated_at = excluded.updated_at
+                """,
+                (key_char, attempts, misses, updated_at),
+            )
+
+    def record_key_stats(self, key_stats: dict[str, tuple[int, int]], updated_at: str) -> None:
+        """Standalone per-key update (used by drills, which feed the coach but
+        are not recorded as competitive races)."""
+        with transaction(self._conn):
+            self._bump_key_stats(key_stats, updated_at)
+
+    def get_key_stats(self) -> dict[str, tuple[int, int]]:
+        rows = self._conn.execute("SELECT key_char, attempts, misses FROM key_stats").fetchall()
+        return {r["key_char"]: (r["attempts"], r["misses"]) for r in rows}
+
     def _bump_profile(self, result: RaceResult) -> None:
         won = 1 if result.ghost_won else 0
         self._conn.execute(
@@ -300,6 +327,13 @@ class SQLiteRepository:
         return self._replay_for("AND q.ext_id = ? ORDER BY r.wpm DESC", (ext_id,))
 
     # ── daily ──────────────────────────────────────────────────────────
+    def daily_days_played(self) -> list[str]:
+        """ISO days (YYYY-MM-DD, ascending) on which the daily was attempted."""
+        rows = self._conn.execute(
+            "SELECT day FROM daily_challenge WHERE attempts > 0 ORDER BY day"
+        ).fetchall()
+        return [r["day"] for r in rows]
+
     def get_or_create_daily(self, day: str, quote: Quote) -> DailyChallenge:
         quote_id = self.upsert_quote(quote)
         row = self._conn.execute("SELECT * FROM daily_challenge WHERE day = ?", (day,)).fetchone()

typefaster/net/api.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+import contextlib
 from typing import Any
 
 import httpx
 
-from .token_store import Session
+from .token_store import DEFAULT_SERVER_URL, Session
 
 
 class ApiError(Exception):
@@ -19,7 +20,11 @@ class ApiError(Exception):
 class ApiClient:
     def __init__(self, session: Session, timeout: float = 10.0) -> None:
         self.session = session
+        self._timeout = timeout
         self._client = httpx.Client(base_url=session.server_url, timeout=timeout)
+        # Set when a connection failure forced a fallback to the default server,
+        # so callers can surface a one-time "saved server was unreachable" notice.
+        self.failed_over = False
 
     def close(self) -> None:
         self._client.close()
@@ -40,7 +45,17 @@ class ApiClient:
         try:
             resp = self._client.request(method, path, **kwargs)
         except httpx.HTTPError as exc:
-            raise ApiError(0, f"connection failed: {exc}") from exc
+            # A connection-level failure (DNS/unreachable) against a non-default
+            # server may mean the saved server is dead. Retry once on the default
+            # and, if that works, persist it so the user self-heals.
+            if self.session.server_url != DEFAULT_SERVER_URL and not self.failed_over:
+                self._failover_to_default()
+                try:
+                    resp = self._client.request(method, path, **kwargs)
+                except httpx.HTTPError as exc2:
+                    raise ApiError(0, f"connection failed: {exc2}") from exc2
+            else:
+                raise ApiError(0, f"connection failed: {exc}") from exc
         if resp.status_code >= 400:
             detail = _extract_detail(resp)
             raise ApiError(resp.status_code, detail)
@@ -48,6 +63,16 @@ class ApiClient:
             return None
         return resp.json()
 
+    def _failover_to_default(self) -> None:
+        """Switch the session to the default server, persist it, and rebuild the
+        underlying client so the retry targets the new base URL."""
+        self.session.server_url = DEFAULT_SERVER_URL
+        with contextlib.suppress(OSError):
+            self.session.save()  # persistence is best-effort; in-memory switch still works
+        self._client.close()
+        self._client = httpx.Client(base_url=DEFAULT_SERVER_URL, timeout=self._timeout)
+        self.failed_over = True
+
     # ── auth ───────────────────────────────────────────────────────────
     # These return parsed JSON; typed as Any since the shape is documented
     # by the server's response models rather than enforced client-side.

typefaster/net/commands.py

@@ -93,8 +93,7 @@ def _oauth_login(provider: str) -> None:
         deadline = time.time() + int(start.get("expires_in", 900))
 
         console.print(
-            f"\n  Open [bold underline]{uri}[/]\n"
-            f"  Enter code: [bold cyan]{code}[/]\n"
+            f"\n  Open [bold underline]{uri}[/]\n" f"  Enter code: [bold cyan]{code}[/]\n"
         )
         with contextlib.suppress(Exception):
             webbrowser.open(uri)

typefaster/net/token_store.py

@@ -2,29 +2,66 @@
 
 from __future__ import annotations
 
+import base64
 import json
+import time
 from dataclasses import asdict, dataclass
 from pathlib import Path
+from urllib.parse import urlsplit
 
 from ..infra.paths import config_dir
 
+# Single source of truth for the public TYPEFASTER server. A fresh install can
+# register/play with zero config; override with `typefaster config set-server`
+# (e.g. a local server or your own deployment).
+DEFAULT_SERVER_URL = "https://140.245.248.113.sslip.io"
+
 
 def _auth_path() -> Path:
     return config_dir() / "auth.json"
 
 
+def _is_ephemeral_host(url: str) -> bool:
+    """True for throwaway tunnel hosts that never persist (e.g. Cloudflare
+    quick-tunnels). A saved URL like these is always stale and safe to reset."""
+    host = (urlsplit(url).hostname or "").lower()
+    return host.endswith(".trycloudflare.com")
+
+
+def _is_token_expired(token: str | None) -> bool:
+    """Check if JWT token is expired by decoding and comparing exp claim.
+    Frontend validation for UX; server always validates for security.
+    Expects JWT format: header.payload.signature (3 parts, 2 dots).
+    Non-JWT tokens are assumed valid."""
+    if not token:
+        return True
+    parts = token.split(".")
+    if len(parts) != 3:
+        return False
+    try:
+        payload = parts[1]
+        decoded = json.loads(base64.urlsafe_b64decode(payload + "=="))
+        if not isinstance(decoded, dict):
+            return True
+        exp = decoded.get("exp")
+        if exp is None or not isinstance(exp, (int, float)):
+            return False
+        return time.time() > exp
+    except Exception:
+        return True
+
+
 @dataclass(slots=True)
 class Session:
-    # Default points at the public TYPEFASTER server so a fresh install can
-    # register/play with zero config. Override with `typefaster config set-server`
-    # (e.g. a local server or your own deployment).
-    server_url: str = "https://140.245.248.113.sslip.io"
+    server_url: str = DEFAULT_SERVER_URL
     token: str | None = None
     username: str | None = None
 
     @property
     def logged_in(self) -> bool:
-        return bool(self.token)
+        if not self.token:
+            return False
+        return not _is_token_expired(self.token)
 
     @classmethod
     def load(cls, path: Path | None = None) -> Session:
@@ -36,7 +73,14 @@ class Session:
         except (json.JSONDecodeError, OSError):
             return cls()
         known = set(cls.__slots__)
-        return cls(**{k: v for k, v in data.items() if k in known})
+        session = cls(**{k: v for k, v in data.items() if k in known})
+        # Self-heal: a saved ephemeral-tunnel URL (from early testing) is dead and
+        # can never come back. Reset it to the default so online play works again
+        # without the user having to run `config set-server`.
+        if _is_ephemeral_host(session.server_url):
+            session.server_url = DEFAULT_SERVER_URL
+            session.save(path)
+        return session
 
     def save(self, path: Path | None = None) -> None:
         path = path or _auth_path()

typefaster/services/coach_service.py

@@ -0,0 +1,52 @@
+"""Typing coach — deterministic analysis over local per-key stats.
+
+Fully offline and free: ranks the keys you miss most and exposes a per-key
+accuracy map. No network, no LLM. Reads the running ``key_stats`` aggregate the
+repository accumulates after every race.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..infra.repository import Repository
+
+
+@dataclass(frozen=True, slots=True)
+class KeyAccuracy:
+    key: str
+    attempts: int
+    misses: int
+    accuracy: float  # 0..1
+
+
+class CoachService:
+    # Below this many total keypresses the data is too thin to coach on.
+    MIN_TOTAL_ATTEMPTS = 50
+
+    def __init__(self, repo: Repository) -> None:
+        self._repo = repo
+
+    def enough_data(self) -> bool:
+        stats = self._repo.get_key_stats()
+        return sum(attempts for attempts, _ in stats.values()) >= self.MIN_TOTAL_ATTEMPTS
+
+    def weakest_keys(self, *, min_attempts: int = 20, limit: int = 10) -> list[KeyAccuracy]:
+        """Keys with the worst accuracy, ignoring keys with too few attempts so a
+        single typo can't dominate. Worst first; ties broken by more attempts."""
+        out: list[KeyAccuracy] = []
+        for key, (attempts, misses) in self._repo.get_key_stats().items():
+            if attempts < min_attempts:
+                continue
+            accuracy = (attempts - misses) / attempts
+            out.append(KeyAccuracy(key=key, attempts=attempts, misses=misses, accuracy=accuracy))
+        out.sort(key=lambda k: (k.accuracy, -k.attempts))
+        return out[:limit]
+
+    def heatmap(self) -> dict[str, float]:
+        """Per-key accuracy (0..1) for every key seen, for rendering."""
+        return {
+            key: (attempts - misses) / attempts
+            for key, (attempts, misses) in self._repo.get_key_stats().items()
+            if attempts > 0
+        }

typefaster/services/container.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from ..infra.config import Settings
 from ..infra.sqlite_repository import SQLiteRepository
+from .coach_service import CoachService
 from .daily_service import DailyService
 from .ghost_service import GhostService
 from .profile_service import ProfileService
@@ -23,6 +24,7 @@ class App:
     stats: StatsService
     daily: DailyService
     ghosts: GhostService
+    coach: CoachService
 
     def close(self) -> None:
         self.repo.close()
@@ -34,9 +36,15 @@ def build_app(db_path: Path | str | None = None) -> App:
     return App(
         settings=settings,
         repo=repo,
-        race=RaceService(repo, allow_backspace=settings.allow_backspace),
+        race=RaceService(
+            repo,
+            allow_backspace=settings.allow_backspace,
+            lowercase_only=settings.lowercase_only,
+            words_only=settings.words_only,
+        ),
         profile=ProfileService(repo),
         stats=StatsService(repo),
         daily=DailyService(repo),
         ghosts=GhostService(repo),
+        coach=CoachService(repo),
     )

typefaster/services/daily_service.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import UTC, date, datetime
+from datetime import UTC, date, datetime, timedelta
 
 from ..domain.models import DailyChallenge, RaceRecord
 from ..infra import quote_loader
@@ -32,3 +32,15 @@ class DailyService:
     def leaderboard(self, day: date | None = None, limit: int = 20) -> list[RaceRecord]:
         day = day or _utc_today()
         return self._repo.daily_leaderboard(day.isoformat(), limit=limit)
+
+    def streak(self, day: date | None = None) -> int:
+        """Consecutive daily-challenge days ending today (or yesterday, if today
+        hasn't been played yet — the streak is still alive, just not extended)."""
+        today = day or _utc_today()
+        played = set(self._repo.daily_days_played())
+        cursor = today if today.isoformat() in played else today - timedelta(days=1)
+        n = 0
+        while cursor.isoformat() in played:
+            n += 1
+            cursor -= timedelta(days=1)
+        return n

typefaster/services/race_service.py

@@ -13,9 +13,11 @@ Two race kinds (see ``RaceKind``):
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import UTC, date, datetime
+from datetime import UTC, datetime
 
+from ..domain.drills import build_drill
 from ..domain.models import Ghost, GhostKind, Quote, RaceKind, RaceMode, RaceResult
+from ..domain.text_modifiers import apply_modifiers
 from ..infra import quote_loader
 from ..infra.repository import Repository
 from .ghost_service import GhostService
@@ -23,6 +25,10 @@ from .ghost_service import GhostService
 # Placeholder quote row that TIME-mode races reference (they have no single text).
 _TIME_QUOTE = Quote(ext_id="__time_mode__", text="(time mode)", source="Time")
 
+# Synthetic ext_id for coach drills: they feed per-key stats but are not recorded
+# as competitive races (no PB, leaderboard, or history).
+_DRILL_EXT_ID = "__drill__"
+
 
 @dataclass(frozen=True, slots=True)
 class RaceConfig:
@@ -55,10 +61,36 @@ class RaceSummary:
 
 
 class RaceService:
-    def __init__(self, repo: Repository, *, allow_backspace: bool = True) -> None:
+    def __init__(
+        self,
+        repo: Repository,
+        *,
+        allow_backspace: bool = True,
+        lowercase_only: bool = False,
+        words_only: bool = False,
+    ) -> None:
         self._repo = repo
         self._ghosts = GhostService(repo)
         self._allow_backspace = allow_backspace
+        self._lowercase_only = lowercase_only
+        self._words_only = words_only
+
+    def set_modifiers(self, *, lowercase_only: bool, words_only: bool) -> None:
+        """Update the active text modifiers live (e.g. from the Settings screen)
+        so a toggle applies to the next race without restarting the app."""
+        self._lowercase_only = lowercase_only
+        self._words_only = words_only
+
+    def set_backspace(self, allow: bool) -> None:
+        """Apply the backspace setting live, same contract as set_modifiers."""
+        self._allow_backspace = allow
+
+    def _modify(self, text: str) -> str:
+        """Apply the active text modifiers to what the player will type. The
+        original quote is still persisted; only the target text changes. Ghosts
+        stay percentage-based, so they still render over modified text (a
+        modified run just isn't apples-to-apples with an unmodified ghost)."""
+        return apply_modifiers(text, lowercase=self._lowercase_only, words_only=self._words_only)
 
     def prepare(
         self,
@@ -77,7 +109,9 @@ class RaceService:
     ) -> RaceSetup:
         ghost: Ghost | None = None
         if daily:
-            quote = quote_loader.daily_quote(date.today())
+            # UTC, matching DailyService/DailyScreen — otherwise a local-midnight
+            # window would race a different quote than the challenge records.
+            quote = quote_loader.daily_quote(datetime.now(UTC).date())
             # Daily ghost = your best run on *today's* quote (same text), if any.
             ghost = self._ghosts.best_for_quote(quote.ext_id)
         elif ghost_kind is not None:
@@ -93,7 +127,7 @@ class RaceService:
 
         return RaceSetup(
             quote=quote,
-            target_text=quote.text,
+            target_text=self._modify(quote.text),
             kind=RaceKind.QUOTE,
             mode=mode,
             ghost=ghost,
@@ -109,7 +143,7 @@ class RaceService:
         text = _stream_text(target_chars)
         return RaceSetup(
             quote=_TIME_QUOTE,
-            target_text=text,
+            target_text=self._modify(text),
             kind=RaceKind.TIME,
             mode=mode,
             ghost=None,  # ghosts are a QUOTE-mode feature
@@ -118,7 +152,28 @@ class RaceService:
             started_at=datetime.now(UTC).isoformat(),
         )
 
+    def prepare_drill(self, weak_keys: list[str], *, length: int = 30) -> RaceSetup:
+        """Build a practice race whose text is weighted toward the player's weak
+        keys. Drills feed the coach's per-key stats but never set records."""
+        text = build_drill(weak_keys, list(quote_loader.corpus_words()), length=length)
+        return RaceSetup(
+            quote=Quote(ext_id=_DRILL_EXT_ID, text=text, source="Drill"),
+            target_text=text,
+            kind=RaceKind.QUOTE,
+            mode=RaceMode.NORMAL,
+            ghost=None,
+            allow_backspace=self._allow_backspace,
+            is_daily=False,
+            started_at=datetime.now(UTC).isoformat(),
+        )
+
     def finish(self, setup: RaceSetup, result: RaceResult) -> RaceSummary:
+        if setup.quote.ext_id == _DRILL_EXT_ID:
+            # Practice only: improve the coach heatmap, don't record a race.
+            self._repo.record_key_stats(result.key_stats, setup.started_at)
+            return RaceSummary(
+                result=result, race_id=0, new_personal_best=False, previous_best_wpm=0.0
+            )
         # Compare against the best of the *same* kind so the two don't mix.
         previous_best = self._best_wpm_for_kind(result.kind)
         race_id = self._repo.save_race(

typefaster/ui/app.py

@@ -9,6 +9,7 @@ from ..services.container import App as Services
 from ..services.container import build_app
 from ..services.race_service import RaceConfig, RaceSetup
 from .screens.account import AccountScreen
+from .screens.coach import CoachScreen
 from .screens.daily import DailyScreen
 from .screens.help import HelpScreen
 from .screens.history import HistoryScreen
@@ -27,6 +28,7 @@ _PANELS = {
     "practice": PracticeScreen,
     "daily": DailyScreen,
     "stats": StatsScreen,
+    "coach": CoachScreen,
     "history": HistoryScreen,
     "profile": ProfileScreen,
     "leaderboard": LeaderboardScreen,
@@ -75,6 +77,13 @@ class TypefasterApp(App[None]):
         self._last_config = config
         self.push_screen(RaceScreen(setup), lambda result: self._after_race(setup, result))
 
+    def start_drill(self) -> None:
+        """Launch a coach drill weighted toward the player's weakest keys."""
+        weak = [k.key for k in self.services.coach.weakest_keys()]
+        setup = self.services.race.prepare_drill(weak)
+        self._last_config = None  # drills regenerate each time, not via "again"
+        self.push_screen(RaceScreen(setup), lambda result: self._after_race(setup, result))
+
     def _after_race(self, setup: RaceSetup, result: RaceResult | None) -> None:
         if result is None:
             return  # race quit — return to whatever is underneath

typefaster/ui/screens/coach.py

@@ -0,0 +1,112 @@
+"""Typing Coach screen — most-missed keys, a per-key heatmap, and finger tips.
+
+All local and deterministic: it reads the offline per-key stats the coach service
+aggregates. No network, no LLM.
+"""
+
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.table import Table
+from rich.text import Text
+
+from ...domain import keyboard
+from ...services.coach_service import KeyAccuracy
+from ._base import PanelScreen
+
+
+def _key_label(key: str) -> str:
+    return "␣" if key == " " else key.upper()
+
+
+def _heat_style(accuracy: float) -> str:
+    if accuracy >= 0.98:
+        return "bold green"
+    if accuracy >= 0.95:
+        return "yellow"
+    return "bold red"
+
+
+class CoachScreen(PanelScreen):
+    title_text = "TYPING COACH"
+    BINDINGS = [
+        ("escape", "back", "Back"),
+        ("q", "back", "Back"),
+        ("d", "drill", "Drill weak keys"),
+    ]
+
+    def action_drill(self) -> None:
+        coach = self.app.services.coach  # type: ignore[attr-defined]
+        if coach.enough_data():
+            self.app.start_drill()  # type: ignore[attr-defined]
+
+    def body(self) -> RenderableType:
+        coach = self.app.services.coach  # type: ignore[attr-defined]
+        if not coach.enough_data():
+            return Text(
+                "Play a few races to unlock your coach.\n\n"
+                "Once you've typed enough, this shows the keys you miss most, a\n"
+                "keyboard heatmap, and how to position your fingers to fix them.",
+                justify="center",
+                style="grey58",
+            )
+
+        weak = coach.weakest_keys()
+        return Group(
+            self._weak_table(weak),
+            Text(""),
+            Text("Keyboard heatmap", style="bold"),
+            self._heatmap(coach.heatmap()),
+            Text("green ≥98%   yellow ≥95%   red <95%   dim = not enough data", style="grey42"),
+            Text(""),
+            Text("Finger positioning", style="bold"),
+            self._tips(weak),
+            Text(""),
+            Text("press  d  to drill your weak keys", style="bold cyan", justify="center"),
+        )
+
+    def _weak_table(self, weak: list[KeyAccuracy]) -> Table:
+        tbl = Table(title="Most-missed keys", title_style="bold")
+        tbl.add_column("Key", justify="center")
+        tbl.add_column("Accuracy", justify="right")
+        tbl.add_column("Misses", justify="right")
+        tbl.add_column("Attempts", justify="right")
+        if not weak:
+            tbl.add_row("—", "great!", "0", "—")
+        for k in weak:
+            tbl.add_row(
+                _key_label(k.key),
+                Text(f"{k.accuracy * 100:.1f}%", style=_heat_style(k.accuracy)),
+                str(k.misses),
+                str(k.attempts),
+            )
+        return tbl
+
+    def _heatmap(self, heat: dict[str, float]) -> Text:
+        out = Text()
+        for indent, row in enumerate(keyboard.ROWS):
+            out.append("  " * indent)
+            for ch in row:
+                if ch in heat:
+                    out.append(f"{ch.upper()} ", style=_heat_style(heat[ch]))
+                else:
+                    out.append(f"{ch.upper()} ", style="grey37")
+            out.append("\n")
+        return out
+
+    def _tips(self, weak: list[KeyAccuracy]) -> RenderableType:
+        tbl = Table.grid(padding=(0, 2))
+        tbl.add_column(justify="center", style="bold cyan")
+        tbl.add_column(justify="left")
+        shown = 0
+        for k in weak:
+            info = keyboard.key_info(k.key)
+            if info is None:
+                continue
+            tbl.add_row(_key_label(k.key), info.tip)
+            shown += 1
+            if shown >= 5:
+                break
+        if shown == 0:
+            return Text("Nothing to fix — your weak keys are all solid.", style="grey58")
+        return tbl

typefaster/ui/screens/daily.py

@@ -47,6 +47,10 @@ class DailyScreen(Screen[None]):
             f"\nYour best today: {challenge.best_wpm:.0f} wpm  ·  attempts {challenge.attempts}\n",
             style="bold",
         )
+        streak = svc.daily.streak()
+        if streak:
+            unit = "day" if streak == 1 else "days"
+            quote.append(f"🔥 Streak: {streak} {unit}\n", style="bold yellow")
 
         table = Table(title="Local daily leaderboard", title_style="bold", expand=True)
         table.add_column("#", justify="right")

typefaster/ui/screens/main_menu.py

@@ -42,6 +42,7 @@ class MainMenu(Screen[None]):
             ("online", "🌐 Play Online  (multiplayer lobbies)"),
             ("account", "🌐 Account / Login"),
             ("stats", "Stats"),
+            ("coach", "🎯 Typing Coach"),
             ("history", "History"),
             ("profile", "Profile"),
             ("leaderboard", "Leaderboard"),

typefaster/ui/screens/online_race.py

@@ -162,7 +162,11 @@ class OnlineRaceScreen(Screen[None]):
             ),
             name="progress",
         )
-        if self._start_ms is not None and elapsed >= self.mode_seconds * 1000 and not self._finished:
+        if (
+            self._start_ms is not None
+            and elapsed >= self.mode_seconds * 1000
+            and not self._finished
+        ):
             self._submit_finish()
 
     def on_key(self, event: events.Key) -> None:
@@ -219,7 +223,9 @@ class OnlineRaceScreen(Screen[None]):
 
     # ── rendering ──────────────────────────────────────────────────────
     def _render_status(self) -> None:
-        self.query_one("#net-status", Static).update(Text.from_markup(self._status, justify="center"))
+        self.query_one("#net-status", Static).update(
+            Text.from_markup(self._status, justify="center")
+        )
 
     def _render_lobby(self, data: dict[str, Any]) -> None:
         name = data.get("name", "Lobby")
@@ -278,7 +284,7 @@ class OnlineRaceScreen(Screen[None]):
                 str(i),
                 f"{row.get('username', '?')}{flag}",
                 f"{row.get('wpm', 0):.0f}",
-                f"{row.get('accuracy', 0) * 100:.0f}%",
+                f"{row.get('accuracy', 0) * 100:.1f}%",
             )
         self.query_one("#net-status", Static).update(
             Text("RACE COMPLETE", justify="center", style="bold green")

typefaster/ui/screens/results.py

@@ -14,6 +14,16 @@ from ...services.race_service import RaceSetup, RaceSummary
 from ..widgets import bigtext
 
 
+def _top_missed(key_stats: dict[str, tuple[int, int]], limit: int = 3) -> str:
+    """Format this race's most-fumbled keys, worst first — e.g. 'E x4 . R x2' (rendered with multiplication signs)."""
+    worst = sorted(
+        ((k, m) for k, (_, m) in key_stats.items() if m > 0),
+        key=lambda km: km[1],
+        reverse=True,
+    )[:limit]
+    return " · ".join(f"{'␣' if k == ' ' else k.upper()} ×{m}" for k, m in worst)
+
+
 class ResultsScreen(Screen[str]):
     """Shows the outcome. Dismisses with an action string: 'again' or 'menu'.
 
@@ -55,6 +65,12 @@ class ResultsScreen(Screen[str]):
             table.add_row("Chars", f"{r.correct_chars} correct · {r.incorrect_chars} wrong")
             table.add_row("Completion", f"{r.progress * 100:.0f}%")
             table.add_row("Time", f"{r.duration_ms / 1000:.1f}s")
+            missed = _top_missed(r.key_stats)
+            if missed:
+                table.add_row(
+                    "Missed keys",
+                    f"[bold red]{missed}[/]  [grey58]· 🎯 Typing Coach can drill these[/]",
+                )
             if self.summary and self.summary.new_personal_best:
                 table.add_row(
                     "Personal best",

typefaster/ui/screens/settings.py

@@ -47,6 +47,8 @@ class SettingsScreen(Screen[None]):
             ),
             ("default_ghost", f"Default ghost   ‹ {s.default_ghost} ›"),
             ("sound", f"Sound (bell)    ‹ {'on' if s.sound else 'off'} ›"),
+            ("lowercase_only", f"Lowercase only  ‹ {'on' if s.lowercase_only else 'off'} ›"),
+            ("words_only", f"Words only      ‹ {'on' if s.words_only else 'off'} ›"),
         ]
         for key, label in rows:
             ol.add_option(Option(label, id=key))
@@ -64,7 +66,18 @@ class SettingsScreen(Screen[None]):
             s.default_ghost = self._cycle(self._GHOSTS, s.default_ghost)
         elif key == "sound":
             s.sound = not s.sound
+        elif key == "lowercase_only":
+            s.lowercase_only = not s.lowercase_only
+        elif key == "words_only":
+            s.words_only = not s.words_only
         s.save()
+        # Apply gameplay-affecting changes to the live race service immediately.
+        if key in ("lowercase_only", "words_only"):
+            self.app.services.race.set_modifiers(  # type: ignore[attr-defined]
+                lowercase_only=s.lowercase_only, words_only=s.words_only
+            )
+        elif key == "allow_backspace":
+            self.app.services.race.set_backspace(s.allow_backspace)  # type: ignore[attr-defined]
         idx = event.option_index
         self._refresh()
         self.query_one(OptionList).highlighted = idx

{typefaster_cli-0.2.0.dist-info → typefaster_cli-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typefaster-cli
-Version: 0.2.0
+Version: 0.3.1
 Summary: A terminal-first typing game inspired by MonkeyType and TypeRacer.
 Project-URL: Homepage, https://github.com/Anoshor/typefaster-cli
 Project-URL: Repository, https://github.com/Anoshor/typefaster-cli
@@ -53,14 +53,16 @@ typefaster
 **Homebrew** (macOS / Linux)
 ```bash
 brew install Anoshor/typefaster/typefaster
+# or tap once, then use the short name:
+brew tap anoshor/typefaster && brew install typefaster
 ```
 
-**pipx** (any OS with Python 3.11+) — fastest
+**pipx** (any OS with Python 3.11+) — fastest install
 ```bash
 pipx install typefaster-cli
 ```
 
-Verify: `typefaster version`
+Verify: `typefaster version` · Upgrade: `brew upgrade typefaster` or `pipx upgrade typefaster-cli`
 
 ## Play (offline — no account, no internet)
 
@@ -73,8 +75,14 @@ Keyboard-only menu:
 - **Time Attack** — type for 30 / 60 / 120s (←/→ to change the duration inline).
 - **Practice** — pick a mode/ghost.
 - **Daily Challenge** — same quote for everyone each day, local leaderboard.
+- **🎯 Typing Coach** — see the keys you miss most, a per-key accuracy heatmap, and
+  finger-position tips; press **d** to launch a drill weighted toward your weak
+  keys. All computed locally — no account, no internet, no AI service.
 - **Stats / History / Profile / Leaderboard / Settings**.
 
+**Practice modes (MonkeyType-style):** in **Settings**, toggle **Lowercase only**
+or **Words only** (pure a–z, no punctuation or numbers) to strip the text down.
+
 Live WPM, accuracy, progress, and an animated ghost bar. Backspace corrects
 mistakes (original errors still count, MonkeyType-style). All progress is saved
 locally in SQLite.
@@ -136,9 +144,11 @@ Deploy guides: [`docs/deploy-oracle.md`](docs/deploy-oracle.md) (free 24/7 VM)
 ```bash
 make install     # editable install + dev deps
 make play        # run it
-make check       # ruff + mypy + pytest
+make check       # ruff + mypy + pytest  (CI parity)
 ```
-Contributions welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+Contributions welcome! `main` is protected — fork, branch, and open a PR; CI must
+pass and a maintainer review is required before merge. Full guide:
+[CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 

{typefaster_cli-0.2.0.dist-info → typefaster_cli-0.3.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-typefaster/__init__.py,sha256=cfdYbT59dWFZ4oxJu7NWC94LrR8lKT_ZagPhY6DjWAM,78
+typefaster/__init__.py,sha256=9aHe77_XFkp9l6PfpQqspmt2xKjgHMbhFUIrz3VrTw8,78
 typefaster/__main__.py,sha256=2dxSnCI2wKDhIgdMFPwlZkdbJ-GQwy6uZApfeoyFAkA,135
 typefaster/cli.py,sha256=NnKzBjvFtr36tBgA5x4XgCuqWo-QGB_40XLLy34Gu9I,6549
 typefaster/assets/__init__.py,sha256=uDRfxDegVWAPzgSUlv-yy_ILP5UTMVIa9lNTh4moyU4,43
@@ -6,58 +6,63 @@ typefaster/assets/quotes.json,sha256=ooE992FtEyzB6-cJ6BEPx_Hfzs5iSekEb8wPvqvOHP4
 typefaster/domain/__init__.py,sha256=5y9Qy9eMH_c75Gq_um7E-6qVPB1a2r0flS-yIVaCqEk,73
 typefaster/domain/anti_cheat.py,sha256=zwB5-ZPANMX63zWxwDn8d9EPtW3kf6PGQ1g-35fAQeM,1429
 typefaster/domain/calculators.py,sha256=Igj1ivDyM67Uf-7hu6hm9H2BCOAvbgaqQ_a0dU6H6t8,1438
+typefaster/domain/drills.py,sha256=2RFUIv2sg19upvqhuMhS1seLqRtwtk2gy8aYPMEtvLg,1354
 typefaster/domain/errors.py,sha256=AP-wzNosxDpxAwtQ8cXfhl32xVGodm3ablp2wawJeak,493
 typefaster/domain/ghost.py,sha256=ilLKCJ24nJs3NQvpetuQwJxJaeq0t6QOrGYYEydbnvQ,2072
-typefaster/domain/models.py,sha256=3WfhzH2lrtWdqxuieBOX81WnprAaNuYQepS-VLMGmoE,4418
-typefaster/domain/typing_engine.py,sha256=D27fCvog5k7i9sygVWvchNojA4cS7Rl5noU8O5AoTAo,5559
+typefaster/domain/keyboard.py,sha256=bdp_dO3DWGXFa35ZMgLEPM7jIjv-NCr1pstlIjQsFOk,2162
+typefaster/domain/models.py,sha256=n3EKliBns9Ta4yRefgUmv7oWcXPX6Rzq1D4MnQT8Kqc,4567
+typefaster/domain/text_modifiers.py,sha256=e-xOsl4ZfK7iKaBUVhptOQ45j-n5ckL3_9BY6X9XO2U,1288
+typefaster/domain/typing_engine.py,sha256=FSwukYbdU73bBFudAuNNMLCKVDEqkv1ShaMENEC4nQY,6392
 typefaster/infra/__init__.py,sha256=i_oY7TZxRHpRRp61_m-qQWsg8qk0CTVHxHT9UGV1do4,76
 typefaster/infra/clock.py,sha256=6DZWBtaTueN0cisnFEXs9bwLuNWb1NOY8e8LiC7w8Nc,775
-typefaster/infra/config.py,sha256=Tz1waDd6QuvVYB0NE0rkbtS5a1mowsoLpx9KlFt4kuM,1229
+typefaster/infra/config.py,sha256=nsu3P41EyBzr5dikW132qbe4Qm2U-Z9cFmc-27Mg3k4,1361
 typefaster/infra/db.py,sha256=5S2v-o__L9EYaFAyg6WmS7eRL2qszwZIv_S23IHB4AM,942
-typefaster/infra/migrations.py,sha256=kb6VNWw42JNck3yyF_9pQUcIVzn7EaFbJsORqZBNg2g,3995
+typefaster/infra/migrations.py,sha256=JRr2CcDjK36ygIDmeNHfnhd_5sUNaQG3nASYEQSrV2s,4433
 typefaster/infra/paths.py,sha256=aH8IeRj34_-_mG4C5450bE_mvThgy3B6Xb4ZSnWxcSY,877
-typefaster/infra/quote_loader.py,sha256=OPfjJ-6Mn1oeaAgZMcsIG6Yt4FePeRngccdO6mX0Jk4,1622
+typefaster/infra/quote_loader.py,sha256=j8QsBVNpwbm1UvQ7sZ3iubhpU0MV6vmKUs0C2BYLhG0,2083
 typefaster/infra/replay_store.py,sha256=dwkjHPFy9-yx3x9BC_THZoY8da3H3EChpQerzlnQGA8,474
-typefaster/infra/repository.py,sha256=WS76T0tWsySV65oB6I4C8REFLoCF3aFlciB0pDoSQ2c,2026
-typefaster/infra/sqlite_repository.py,sha256=XRtT8Q3tbi9cbuQIYCqfHly54rKF_koLT1Dw57R2OEM,14694
+typefaster/infra/repository.py,sha256=VsW8yDb4ArZCJfrn1RvixZMYPxmzH19rjX9bkgYxwsc,2275
+typefaster/infra/sqlite_repository.py,sha256=G-o-b2gu-ZnNEV7Nq2LHE1c26lljKaO2g8-RqJF8T1k,16388
 typefaster/net/__init__.py,sha256=tSx4UMBc0kUlp60corti6SvOnc9fJ_n5guJlysdRUZ0,74
-typefaster/net/api.py,sha256=dxYx5VUkADjK_65rKNoR2kz8V4EDPnnU3dO_fjaZ2j8,4440
-typefaster/net/commands.py,sha256=OBsP3DbfAHz-1LmQX0B2FZB0cVIuTQ_od2tCNfQBpy4,9791
-typefaster/net/token_store.py,sha256=yZsjNVot9tAEVw_G7_BoqFUKcbLHZ9kXh1WG_NQTc7Q,1504
+typefaster/net/api.py,sha256=9B37OcnUqjLgqKMPWu_c8LS2LGApf8uyfHCIrpskPGM,5842
+typefaster/net/commands.py,sha256=Myy-q_YCZ6Qyd2O-RCz09Z0ShytthYldfoHFbmPDP0A,9779
+typefaster/net/token_store.py,sha256=uE07VnC5arw7G70ILq9SdTILSJAsFsjxAhNeAJ42G4c,3137
 typefaster/services/__init__.py,sha256=4VngeItS-jc6-I71DsWkaWnvHODCni7ot4kiDICfMaw,79
-typefaster/services/container.py,sha256=79AR_skykXGsneXZx-LZ6ihbV8x8yzWBBnTQIzeUzK4,1143
-typefaster/services/daily_service.py,sha256=xROI20AYUtoBn332Zn2QBg_4sEPU_Eptu4_O1Xap0Lk,1189
+typefaster/services/coach_service.py,sha256=MgzPULFwX1Rsj-ILxvytoNv-3OdBuDbSIvgN6Sqy5y8,1854
+typefaster/services/container.py,sha256=F62UVI0EG1aPA5obWA3kymG3axTR8jj6wHjex2T2cyg,1372
+typefaster/services/daily_service.py,sha256=q7yh_0Hu4ltXFK1CrYXVrGeh5-N5h-XxACnBuK3EXoE,1729
 typefaster/services/ghost_service.py,sha256=U6XPMDtgi8ORvf6w-mGpyZf8aiHaDD35zZ6F3cjzSsw,1676
 typefaster/services/profile_service.py,sha256=EquonTLismSHcs3HTQlUC_Rtt3uI3CT-Q5igFwRk220,473
-typefaster/services/race_service.py,sha256=BmTMIpjkHX9Wom7PeaWRXHUHuZ4siaVtq-iey2tfwIQ,5406
+typefaster/services/race_service.py,sha256=ujLvawa1gUOzNitS585Ku4vmquF74x4hboMEvB-IMvo,8031
 typefaster/services/stats_service.py,sha256=yLP2hwubhqUr5rPxnxWX9n5PbINpgn9dQc1RANiYBeU,1912
 typefaster/ui/__init__.py,sha256=IbB-ajsaTRD4HS4zy-fNbpkv8_broTEEhJgl_1d93q4,72
-typefaster/ui/app.py,sha256=wr95rqeTBYRjLMo4Mr4usGaxj9CI-QWYSDo50JbdGqg,3591
+typefaster/ui/app.py,sha256=5kU_iCabm4jfws__FGKfBvpF3cvLBEstjRW3wW5lGos,4065
 typefaster/ui/online_app.py,sha256=PHycCB32LGho8hHx9sfJ-o-gyiDT82CUTRRVF5ov33Y,678
 typefaster/ui/theme.py,sha256=XzJFft9L3QP4qqUbbHmZ0v3ZeWodvcUY89PhsEHqlfs,1487
 typefaster/ui/screens/__init__.py,sha256=-L4TEWNuG14Jofv6FNRLMKYGYoNquB1HvGmYV3YXYus,23
 typefaster/ui/screens/_base.py,sha256=yNdf-HUSYgYM5-nNsM622DAiN1DvNDptY_gFH3hk0l0,1184
 typefaster/ui/screens/account.py,sha256=C9xf52ju2XGxA9mkGWqed8goTooZ7ZJmnfPYmsNGNLA,7749
-typefaster/ui/screens/daily.py,sha256=vjHMZ8TNXxNKDNMbyWDPvxcbQK_ff-M8YK0bRtyXuio,2580
+typefaster/ui/screens/coach.py,sha256=WP65Gxh21-vk5fw3eu0moDYANkxxIPZ7m7UNKlImM5A,3835
+typefaster/ui/screens/daily.py,sha256=QGOBYENF-Do4fWerHIuBNS00D06O3MLCH2qgYIPX6kM,2768
 typefaster/ui/screens/help.py,sha256=OCzQlsGWzY7CwZMAcElGxMtBmao_KRjIFse7RuABtNE,788
 typefaster/ui/screens/history.py,sha256=PQ0f5F7aHv1E6pmJvsNNYlbm59HthwAHGtYR0bX_i8s,1073
 typefaster/ui/screens/leaderboard.py,sha256=kZhuixwIZLVsHaDjwsB258sQyMBZ9dYs2Y0QdRaFpKg,1968
 typefaster/ui/screens/lobby_browser.py,sha256=5upNsBBXd_jurXOv1IuQ-C94AvdVZzOzfR68bz209q8,6102
-typefaster/ui/screens/main_menu.py,sha256=HW2Zl8nk_YMZ5r07J51SJ86iShaUCCMu3kl3472j1Eg,4090
-typefaster/ui/screens/online_race.py,sha256=oVHi2FICWMPcEHYXQ0eS8I9Fa6OZInseKSPnGoPZbk8,13302
+typefaster/ui/screens/main_menu.py,sha256=CxHY-MYdlXMgvgtCgH_UPyoAocV32ftycV53S6ga7IM,4134
+typefaster/ui/screens/online_race.py,sha256=RC5jqE5uAMa45WAoVUr8G2DK4dNK4H_w_eeNLSjEqnU,13372
 typefaster/ui/screens/practice.py,sha256=6gvzVFYprGrbDClPArWM4COnzRi0zASrtnKjP6AREx8,2115
 typefaster/ui/screens/profile.py,sha256=1QiUkhMBH38q3Vkw5kx4O1LUZc8vrNtKF8q4p8GABAk,995
 typefaster/ui/screens/race.py,sha256=JlCxayx2W-fjnIza4ASK4Yg-UGkWSXDQv2YkndnxOMY,9961
-typefaster/ui/screens/results.py,sha256=3nXSMEO9xIBEtKRoSzpGNBnRMbX3-yToXCQ1GuLJrZY,3280
-typefaster/ui/screens/settings.py,sha256=nz0VRoRUmJxDj6CGFHiVtL0xDaz4lCvO1qa-l5NqXBE,2812
+typefaster/ui/screens/results.py,sha256=Q4YcU9O2Xe02MZYEDoxwYr-B0GyzGYDz92VnRNlhqFQ,3964
+typefaster/ui/screens/settings.py,sha256=8PIecUQBXzYvSZs5LqCYaUfmOBfw-W97UcUqjrYIh7o,3605
 typefaster/ui/screens/stats.py,sha256=eePL3sU729EptA2DRJOlpezVUgOjE9zPkwT_dOSF0os,2342
 typefaster/ui/widgets/__init__.py,sha256=D2YleDqZvFyzPhI501R-V8RmwDSSvOFRasAyVHpxUBo,56
 typefaster/ui/widgets/bigtext.py,sha256=6naRaTuxke6tP0Q7j67KyvMsibTlRdhdiuEiszNdKYo,2162
 typefaster/ui/widgets/live_stats.py,sha256=Q17tvAOHanhf4qS78G59sLEY-mieAUyDjyvAZN8tAaw,683
 typefaster/ui/widgets/progress_bars.py,sha256=fZTh9a0KPVK1UnRq75Jf0YzSF4r85e3xn12oSUmIzmA,1392
 typefaster/ui/widgets/typing_field.py,sha256=gYKOjytwsMEU_k5Nu9mnYLBP4smNEw4bZ6lR27_m-k0,934
-typefaster_cli-0.2.0.dist-info/METADATA,sha256=ATYsxkT15-Yin4G-8cHJO8Xgbgnb0ffifEaUFblhNZ4,5014
-typefaster_cli-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-typefaster_cli-0.2.0.dist-info/entry_points.txt,sha256=-ix_zmJiKj-cikp7-QfkxqB6MPIYCD0hiGd36Q-XlS8,50
-typefaster_cli-0.2.0.dist-info/licenses/LICENSE,sha256=ZrmIfNfrisYorCVzUnlZHoQZxJQB06oC_0lrNMkkXls,1079
-typefaster_cli-0.2.0.dist-info/RECORD,,
+typefaster_cli-0.3.1.dist-info/METADATA,sha256=fNmnsbp0LykOjeWWo3k53ls72K9OTHJYjghGZ9JXeyE,5728
+typefaster_cli-0.3.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+typefaster_cli-0.3.1.dist-info/entry_points.txt,sha256=-ix_zmJiKj-cikp7-QfkxqB6MPIYCD0hiGd36Q-XlS8,50
+typefaster_cli-0.3.1.dist-info/licenses/LICENSE,sha256=ZrmIfNfrisYorCVzUnlZHoQZxJQB06oC_0lrNMkkXls,1079
+typefaster_cli-0.3.1.dist-info/RECORD,,

{typefaster_cli-0.2.0.dist-info → typefaster_cli-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any