ttyping 0.1.0__py3-none-any.whl

ttyping/__init__.py

@@ -0,0 +1,3 @@
+"""ttyping — A minimal terminal typing test."""
+
+__version__ = "0.1.0"

ttyping/__main__.py

@@ -0,0 +1,61 @@
+"""CLI entry point for ttyping."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="ttyping",
+        description="A minimal terminal typing test",
+    )
+    parser.add_argument(
+        "--lang",
+        choices=["en", "ko"],
+        default="en",
+        help="language for random words (default: en)",
+    )
+    parser.add_argument(
+        "--file",
+        type=str,
+        default=None,
+        help="path to a text file for typing practice",
+    )
+    parser.add_argument(
+        "--words",
+        type=int,
+        default=25,
+        help="number of words to type (default: 25)",
+    )
+    parser.add_argument(
+        "--time",
+        "-t",
+        type=int,
+        default=None,
+        help="duration of the test in seconds (overrides --words)",
+    )
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=["history"],
+        help="subcommand (history: view past results)",
+    )
+
+    args = parser.parse_args()
+
+    from ttyping.app import TypingApp
+
+    app = TypingApp(
+        lang=args.lang,
+        file_path=args.file,
+        word_count=args.words,
+        duration=args.time,
+        show_history=args.command == "history",
+    )
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

ttyping/app.py

@@ -0,0 +1,70 @@
+"""Main Textual application for ttyping."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import App
+
+from ttyping.screens import HistoryScreen, TypingScreen
+from ttyping.words import get_words, words_from_file
+
+
+class TypingApp(App):
+    """A minimal terminal typing test."""
+
+    TITLE = "ttyping"
+
+    CSS = """
+    Screen {
+        background: #323437;
+    }
+    """
+
+    def __init__(
+        self,
+        lang: str = "en",
+        file_path: str | None = None,
+        word_count: int = 25,
+        duration: int | None = None,
+        show_history: bool = False,
+    ) -> None:
+        super().__init__()
+        self._lang = lang
+        self._file_path = file_path
+        self._word_count = word_count
+        self._duration = duration
+        self._show_history = show_history
+
+    def on_mount(self) -> None:
+        if self._show_history:
+            self.push_screen(HistoryScreen())
+        else:
+            self._start_typing()
+
+    def _start_typing(self) -> None:
+        words = self._get_words()
+        self.push_screen(TypingScreen(words, lang=self._lang, duration=self._duration))
+
+    def _get_words(self) -> list[str]:
+        count = self._word_count
+        if self._duration:
+            # For timed tests, provide plenty of words.
+            # 500 is likely more than enough for 1-2 minutes.
+            count = 500
+
+        if self._file_path:
+            return words_from_file(self._file_path, count)
+        return get_words(self._lang, count)
+
+    def restart(self) -> None:
+        """Pop current screens and start a new typing test."""
+        while len(self.screen_stack) > 1:
+            self.pop_screen()
+        self._start_typing()
+
+    def show_result(self, result: dict[str, Any]) -> None:
+        """Push the result screen after a test."""
+        from ttyping.screens import ResultScreen
+
+        self.push_screen(ResultScreen(result))

ttyping/screens.py

@@ -0,0 +1,553 @@
+"""Screens for ttyping: typing test, results, and history."""
+
+from __future__ import annotations
+
+from collections import Counter
+import time
+from datetime import datetime, timezone
+from typing import Any
+
+from rich.text import Text
+from textual import events
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Center, Vertical
+from textual.screen import Screen
+from textual.widgets import DataTable, Input, Static
+
+from ttyping.storage import load_results, save_result
+
+# ── Colours (monkeytype-inspired) ─────────────────────────────────────────
+
+COL_BG = "#323437"
+COL_DIM = "#646669"
+COL_TEXT = "#d1d0c5"
+COL_CORRECT = "#d1d0c5"
+COL_ERROR = "#ca4754"
+COL_ACCENT = "#e2b714"
+COL_SUB_BG = "#2c2e31"
+
+
+# ── TypingScreen ───────────────────────────────────────────────────────────
+
+
+class TypingScreen(Screen):
+    """Main typing test screen."""
+
+    BINDINGS = [
+        Binding("tab", "restart", "Restart", priority=True),
+        Binding("escape", "quit_app", "Quit", priority=True),
+    ]
+
+    DEFAULT_CSS = """
+    TypingScreen {
+        align: center middle;
+    }
+
+    #typing-container {
+        width: 76;
+        height: auto;
+        max-height: 100%;
+        align: center middle;
+    }
+
+    #stats {
+        width: 100%;
+        height: 2;
+        content-align: center middle;
+        text-align: center;
+        color: """ + COL_ACCENT + """;
+        margin-bottom: 1;
+    }
+
+    #text-display {
+        width: 100%;
+        height: auto;
+        min-height: 3;
+        max-height: 8;
+        padding: 0 2;
+    }
+
+    #input-area {
+        width: 100%;
+        margin-top: 1;
+        border: round """ + COL_DIM + """;
+        background: """ + COL_SUB_BG + """;
+        color: """ + COL_TEXT + """;
+        padding: 0 1;
+    }
+
+    #input-area:focus {
+        border: round """ + COL_ACCENT + """;
+    }
+
+    #hints {
+        width: 100%;
+        height: 1;
+        content-align: center middle;
+        text-align: center;
+        color: """ + COL_DIM + """;
+        margin-top: 1;
+    }
+    """
+
+    def __init__(self, words: list[str], lang: str = "en", duration: int | None = None) -> None:
+        super().__init__()
+        self.words = words
+        self.lang = lang
+        self.duration = duration
+        self.current_word_idx = 0
+        self.current_input = ""
+        self.word_correct: list[bool | None] = [None] * len(words)
+        self.start_time: float | None = None
+        self.total_correct_chars = 0
+        self.total_keystrokes = 0
+        self._timer_handle: Any = None
+        self._finished = False
+        self.errors = Counter()  # Tracks characters missed
+        self.word_errors = Counter()  # Tracks words missed
+
+    def compose(self) -> ComposeResult:
+        with Center():
+            with Vertical(id="typing-container"):
+                yield Static("", id="stats")
+                yield Static("", id="text-display")
+                yield Input(placeholder="start typing…", id="input-area")
+                yield Static("tab restart · esc quit", id="hints")
+
+    def on_mount(self) -> None:
+        self._render_display()
+        self.query_one("#input-area", Input).focus()
+
+    # ── input handling ─────────────────────────────────────────────────
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if self._finished:
+            return
+
+        value = event.value
+
+        # Space → complete current word
+        if value.endswith(" "):
+            self._complete_word(value[:-1])
+            event.input.value = ""
+            return
+
+        # Track character errors as they happen
+        if value and self.current_word_idx < len(self.words):
+            target_word = self.words[self.current_word_idx]
+            last_typed_idx = len(value) - 1
+            if last_typed_idx < len(target_word):
+                if value[last_typed_idx] != target_word[last_typed_idx]:
+                    # User typed the wrong character
+                    self.errors[target_word[last_typed_idx]] += 1
+
+        self.current_input = value
+
+        # Start timer on first keystroke
+        if self.start_time is None and value:
+            self.start_time = time.time()
+            self._timer_handle = self.set_interval(0.5, self._tick_stats)
+
+        self._render_display()
+        self._update_stats()
+
+    def on_key(self, event: events.Key) -> None:
+        if self._finished:
+            return
+        # Enter also completes the current word (handy for last word)
+        if event.key == "enter":
+            event.prevent_default()
+            inp = self.query_one("#input-area", Input)
+            if inp.value:
+                self._complete_word(inp.value)
+                inp.value = ""
+
+    # ── word completion ────────────────────────────────────────────────
+
+    def _complete_word(self, typed: str) -> None:
+        target = self.words[self.current_word_idx]
+        is_correct = typed == target
+
+        self.word_correct[self.current_word_idx] = is_correct
+        self.total_keystrokes += len(typed) + 1  # +1 for space/enter
+        if is_correct:
+            self.total_correct_chars += len(target) + 1
+        else:
+            self.word_errors[target] += 1
+
+        self.current_word_idx += 1
+        self.current_input = ""
+
+        if self.current_word_idx >= len(self.words):
+            self._end_test()
+            return
+
+        self._render_display()
+        self._update_stats()
+
+    # ── end test ───────────────────────────────────────────────────────
+
+    def _end_test(self) -> None:
+        if self._finished:
+            return
+
+        self._finished = True
+        if self._timer_handle:
+            self._timer_handle.stop()
+
+        elapsed = time.time() - self.start_time if self.start_time else 0.01
+        minutes = elapsed / 60
+        wpm = (self.total_correct_chars / 5) / minutes if minutes > 0 else 0
+        accuracy = (
+            (self.total_correct_chars / max(self.total_keystrokes, 1)) * 100
+        )
+        correct_words = sum(1 for w in self.word_correct if w is True)
+
+        # Get top errors
+        top_char_errors = self.errors.most_common(5)
+        top_word_errors = self.word_errors.most_common(5)
+
+        result: dict[str, Any] = {
+            "wpm": round(wpm, 1),
+            "accuracy": round(accuracy, 1),
+            "time": round(elapsed, 1),
+            "lang": self.lang,
+            "words": self.current_word_idx,  # Number of words attempted
+            "correct": correct_words,
+            "top_char_errors": top_char_errors,
+            "top_word_errors": top_word_errors,
+        }
+
+        save_result(result)
+        self.app.show_result(result)  # type: ignore[attr-defined]
+
+    # ── rendering ──────────────────────────────────────────────────────
+
+    def _render_display(self) -> None:
+        text = Text()
+        # Only show a window of words around current index to keep it clean,
+        # especially for long timed tests.
+        start = max(0, self.current_word_idx - 10)
+        end = min(len(self.words), self.current_word_idx + 20)
+
+        for i in range(start, end):
+            word = self.words[i]
+            if i > start:
+                text.append(" ")
+
+            if i < self.current_word_idx:
+                # Past word
+                if self.word_correct[i]:
+                    text.append(word, style=f"dim {COL_CORRECT}")
+                else:
+                    text.append(word, style=f"{COL_ERROR} strike")
+            elif i == self.current_word_idx:
+                # Current word — per-character colouring
+                typed = self.current_input
+                for j, ch in enumerate(word):
+                    if j < len(typed):
+                        if typed[j] == ch:
+                            text.append(ch, style=f"bold {COL_CORRECT}")
+                        else:
+                            text.append(ch, style=f"bold {COL_ERROR}")
+                    elif j == len(typed):
+                        text.append(ch, style=f"underline {COL_TEXT}")
+                    else:
+                        text.append(ch, style=COL_DIM)
+                # Extra chars beyond word length
+                if len(typed) > len(word):
+                    text.append(typed[len(word):], style=f"bold {COL_ERROR}")
+            else:
+                # Future word
+                text.append(word, style=COL_DIM)
+
+        self.query_one("#text-display", Static).update(text)
+
+    def _update_stats(self) -> None:
+        if self.start_time is None:
+            self.query_one("#stats", Static).update("")
+            return
+
+        elapsed = time.time() - self.start_time
+        minutes = elapsed / 60
+        wpm = (self.total_correct_chars / 5) / minutes if minutes > 0 else 0
+        accuracy = (
+            (self.total_correct_chars / max(self.total_keystrokes, 1)) * 100
+        )
+
+        t = Text()
+        t.append(f"{wpm:.0f}", style=f"bold {COL_ACCENT}")
+        t.append(" wpm   ", style=COL_DIM)
+        t.append(f"{accuracy:.0f}%", style=f"bold {COL_ACCENT}")
+        t.append(" acc   ", style=COL_DIM)
+
+        if self.duration:
+            remaining = max(0, self.duration - elapsed)
+            t.append(f"{remaining:.0f}s", style=f"bold {COL_ACCENT}")
+        else:
+            t.append(f"{elapsed:.0f}s", style=f"bold {COL_ACCENT}")
+
+        self.query_one("#stats", Static).update(t)
+
+    def _tick_stats(self) -> None:
+        """Called by timer to keep stats ticking even when not typing."""
+        if not self._finished:
+            if self.duration:
+                elapsed = time.time() - self.start_time if self.start_time else 0
+                if elapsed >= self.duration:
+                    self._end_test()
+                    return
+            self._update_stats()
+
+    # ── actions ────────────────────────────────────────────────────────
+
+    def action_restart(self) -> None:
+        self.app.restart()  # type: ignore[attr-defined]
+
+    def action_quit_app(self) -> None:
+        self.app.exit()
+
+
+# ── ResultScreen ───────────────────────────────────────────────────────────
+
+
+class ResultScreen(Screen):
+    """Post-test results."""
+
+    BINDINGS = [
+        Binding("tab", "retry", "Retry", priority=True),
+        Binding("h", "history", "History"),
+        Binding("escape", "quit_app", "Quit"),
+    ]
+
+    DEFAULT_CSS = """
+    ResultScreen {
+        align: center middle;
+    }
+
+    #result-container {
+        width: 60;
+        height: auto;
+        align: center middle;
+        padding: 2 4;
+    }
+
+    .result-big {
+        width: 100%;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    .result-detail {
+        width: 100%;
+        text-align: center;
+        color: """ + COL_DIM + """;
+    }
+
+    #top-errors-title {
+        width: 100%;
+        text-align: center;
+        margin-top: 1;
+        color: """ + COL_DIM + """;
+    }
+
+    #top-errors-graph {
+        width: 100%;
+        margin-top: 1;
+        content-align: center middle;
+    }
+
+    #result-hints {
+        width: 100%;
+        text-align: center;
+        color: """ + COL_DIM + """;
+        margin-top: 2;
+    }
+    """
+
+    def __init__(self, result: dict[str, Any]) -> None:
+        super().__init__()
+        self.result = result
+
+    def compose(self) -> ComposeResult:
+        r = self.result
+        with Center():
+            with Vertical(id="result-container"):
+                wpm_text = Text()
+                wpm_text.append(f"{r['wpm']:.0f}", style=f"bold {COL_ACCENT}")
+                wpm_text.append(" wpm", style=COL_DIM)
+                yield Static(wpm_text, classes="result-big")
+
+                acc_text = Text()
+                acc_text.append(f"{r['accuracy']:.1f}%", style=f"bold {COL_TEXT}")
+                acc_text.append(" accuracy", style=COL_DIM)
+                yield Static(acc_text, classes="result-big")
+
+                detail = Text()
+                detail.append(f"{r['time']:.1f}s", style=COL_TEXT)
+                detail.append(f"  ·  {r['correct']}/{r['words']} words", style=COL_DIM)
+                detail.append(f"  ·  {r['lang']}", style=COL_DIM)
+                yield Static(detail, classes="result-detail")
+
+                if r.get("top_word_errors"):
+                    yield Static("top missed words", id="top-errors-title")
+                    yield Static(self._render_bar_graph(r["top_word_errors"]), id="top-errors-graph")
+                elif r.get("top_char_errors"):
+                    yield Static("top missed characters", id="top-errors-title")
+                    yield Static(self._render_bar_graph(r["top_char_errors"]), id="top-errors-graph")
+
+                yield Static(
+                    "tab retry · h history · esc quit",
+                    id="result-hints",
+                )
+
+    def _render_bar_graph(self, data: list[tuple[str, int]]) -> Text:
+        from rich.cells import cell_len
+
+        if not data:
+            return Text()
+        
+        max_val = max(count for _, count in data)
+        max_bar_width = 30
+        
+        # Determine necessary label cell width
+        max_label_cell_len = 0
+        for label, _ in data:
+            max_label_cell_len = max(max_label_cell_len, cell_len(label))
+        
+        # Cap label width and add padding
+        label_cell_width = min(max_label_cell_len, 15)
+
+        t = Text()
+        for i, (label, count) in enumerate(data):
+            if i > 0:
+                t.append("\n")
+            
+            # Truncate and pad label based on cell width
+            curr_cell_len = cell_len(label)
+            if curr_cell_len > label_cell_width:
+                # Truncate label to fit within label_cell_width-1 cells and add '…'
+                display_label = ""
+                acc_len = 0
+                for char in label:
+                    char_len = cell_len(char)
+                    if acc_len + char_len > label_cell_width - 1:
+                        break
+                    display_label += char
+                    acc_len += char_len
+                display_label += "…"
+                padding = " " * (label_cell_width - cell_len(display_label))
+            else:
+                display_label = label
+                padding = " " * (label_cell_width - curr_cell_len)
+            
+            bar_len = int((count / max_val) * max_bar_width) if max_val > 0 else 0
+            if count > 0 and bar_len == 0:
+                bar_len = 1
+                
+            bar = "█" * bar_len
+            t.append(padding + display_label + " ", style=COL_DIM)
+            t.append(bar, style=COL_ERROR)
+            t.append(f" {count}", style=COL_TEXT)
+        return t
+
+    def action_retry(self) -> None:
+        self.app.restart()  # type: ignore[attr-defined]
+
+    def action_history(self) -> None:
+        self.app.push_screen(HistoryScreen())
+
+    def action_quit_app(self) -> None:
+        self.app.exit()
+
+
+# ── HistoryScreen ──────────────────────────────────────────────────────────
+
+
+class HistoryScreen(Screen):
+    """Past typing results."""
+
+    BINDINGS = [
+        Binding("escape", "go_back", "Back"),
+    ]
+
+    DEFAULT_CSS = """
+    HistoryScreen {
+        align: center middle;
+    }
+
+    #history-container {
+        width: 80;
+        height: auto;
+        max-height: 90%;
+        align: center middle;
+    }
+
+    #history-title {
+        width: 100%;
+        text-align: center;
+        color: """ + COL_ACCENT + """;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+
+    #history-table {
+        width: 100%;
+        height: auto;
+        max-height: 20;
+        background: """ + COL_SUB_BG + """;
+    }
+
+    #history-empty {
+        width: 100%;
+        text-align: center;
+        color: """ + COL_DIM + """;
+        padding: 2;
+    }
+
+    #history-hints {
+        width: 100%;
+        text-align: center;
+        color: """ + COL_DIM + """;
+        margin-top: 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        results = load_results()
+
+        with Center():
+            with Vertical(id="history-container"):
+                yield Static("History", id="history-title")
+
+                if not results:
+                    yield Static("No results yet — go type!", id="history-empty")
+                else:
+                    table = DataTable(id="history-table")
+                    table.add_columns("Date", "WPM", "Acc", "Lang", "Time", "Words")
+                    for r in reversed(results[-50:]):
+                        date_str = ""
+                        if "date" in r:
+                            try:
+                                dt = datetime.fromisoformat(r["date"])
+                                date_str = dt.strftime("%Y-%m-%d %H:%M")
+                            except (ValueError, TypeError):
+                                date_str = str(r["date"])[:16]
+                        table.add_row(
+                            date_str,
+                            f"{r.get('wpm', 0):.0f}",
+                            f"{r.get('accuracy', 0):.1f}%",
+                            r.get("lang", "?"),
+                            f"{r.get('time', 0):.0f}s",
+                            f"{r.get('correct', 0)}/{r.get('words', 0)}",
+                        )
+                    yield table
+
+                yield Static("esc back", id="history-hints")
+
+    def action_go_back(self) -> None:
+        if len(self.app.screen_stack) > 1:
+            self.app.pop_screen()
+        else:
+            self.app.exit()

ttyping/storage.py

@@ -0,0 +1,36 @@
+"""Local JSON storage for typing results."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+STORAGE_DIR = Path.home() / ".ttyping"
+RESULTS_FILE = STORAGE_DIR / "results.json"
+
+
+def _ensure_storage() -> None:
+    STORAGE_DIR.mkdir(parents=True, exist_ok=True)
+    if not RESULTS_FILE.exists():
+        RESULTS_FILE.write_text("[]", encoding="utf-8")
+
+
+def save_result(result: dict[str, Any]) -> None:
+    """Append a result to the local storage."""
+    _ensure_storage()
+    results = load_results()
+    result["date"] = datetime.now(timezone.utc).isoformat()
+    results.append(result)
+    RESULTS_FILE.write_text(json.dumps(results, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def load_results() -> list[dict[str, Any]]:
+    """Load all results from local storage."""
+    _ensure_storage()
+    text = RESULTS_FILE.read_text(encoding="utf-8")
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return []

ttyping/words.py

@@ -0,0 +1,69 @@
+"""Word lists and file reader for ttyping."""
+
+from __future__ import annotations
+
+import random
+from pathlib import Path
+
+ENGLISH: list[str] = [
+    "the", "be", "to", "of", "and", "a", "in", "that", "have", "i",
+    "it", "for", "not", "on", "with", "he", "as", "you", "do", "at",
+    "this", "but", "his", "by", "from", "they", "we", "say", "her", "she",
+    "or", "an", "will", "my", "one", "all", "would", "there", "their", "what",
+    "so", "up", "out", "if", "about", "who", "get", "which", "go", "me",
+    "when", "make", "can", "like", "time", "no", "just", "him", "know", "take",
+    "people", "into", "year", "your", "good", "some", "could", "them", "see", "other",
+    "than", "then", "now", "look", "only", "come", "its", "over", "think", "also",
+    "back", "after", "use", "two", "how", "our", "work", "first", "well", "way",
+    "even", "new", "want", "because", "any", "these", "give", "day", "most", "us",
+    "great", "between", "need", "large", "often", "hand", "high", "place", "small", "found",
+    "live", "where", "before", "must", "home", "big", "long", "much", "right", "still",
+    "world", "start", "house", "every", "under", "keep", "never", "last", "let", "each",
+    "begin", "while", "next", "should", "same", "name", "help", "talk", "turn", "move",
+    "point", "city", "play", "away", "end", "part", "lead", "stand", "own", "page",
+    "learn", "change", "group", "always", "music", "those", "both", "mark", "book", "letter",
+    "until", "life", "children", "write", "close", "open", "run", "read", "line", "set",
+    "air", "animal", "answer", "around", "ask", "best", "better", "black", "body", "boy",
+    "bring", "build", "call", "came", "car", "care", "carry", "child", "city", "cold",
+    "country", "cut", "dear", "door", "draw", "earth", "eat", "face", "fall", "family",
+    "far", "father", "few", "fish", "food", "form", "four", "girl", "got", "green",
+    "grow", "hard", "head", "hear", "hot", "idea", "important", "inside", "keep", "kind",
+    "king", "land", "late", "left", "light", "list", "love", "man", "many", "might",
+    "money", "morning", "mother", "mountain", "near", "night", "nothing", "number", "off", "old",
+    "once", "order", "paper", "picture", "plant", "problem", "put", "quite", "river", "room",
+    "school", "sea", "second", "side", "soon", "story", "stop", "sun", "sure", "table",
+    "tell", "though", "today", "together", "took", "tree", "try", "voice", "walk", "watch",
+    "water", "white", "word", "young", "system", "program", "question", "during", "without", "again",
+]
+
+KOREAN: list[str] = [
+    "사람", "시간", "우리", "세계", "나라", "사회", "학교", "생각", "문제", "오늘",
+    "내일", "어제", "회사", "가족", "친구", "사랑", "행복", "음식", "하늘", "바다",
+    "여행", "공부", "노력", "경험", "기억", "마음", "이유", "방법", "계획", "결과",
+    "의미", "가능", "필요", "중요", "다양", "특별", "자유", "평화", "희망", "미래",
+    "역사", "문화", "예술", "음악", "영화", "도시", "자연", "환경", "건강", "교육",
+    "기술", "과학", "경제", "정치", "법률", "뉴스", "정보", "인터넷", "컴퓨터", "전화",
+    "이름", "나이", "직업", "취미", "여름", "겨울", "봄", "가을", "아침", "저녁",
+    "동물", "식물", "꽃", "나무", "강", "산", "비", "눈", "바람", "구름",
+    "집", "방", "문", "길", "차", "버스", "지하철", "비행기", "기차", "배",
+    "물", "밥", "고기", "과일", "커피", "빵", "국", "김치", "라면", "치킨",
+    "약속", "준비", "시작", "끝", "변화", "성장", "발전", "성공", "실패", "도전",
+    "감사", "미안", "부탁", "인사", "대화", "연락", "소식", "선물", "축하", "응원",
+]
+
+
+def get_words(lang: str = "en", count: int = 25) -> list[str]:
+    """Return a random selection of words for the given language."""
+    source = ENGLISH if lang == "en" else KOREAN
+    return [random.choice(source) for _ in range(count)]
+
+
+def words_from_file(path: str, count: int = 25) -> list[str]:
+    """Read words from a file and return up to `count` words."""
+    text = Path(path).read_text(encoding="utf-8")
+    words = text.split()
+    if not words:
+        raise ValueError(f"No words found in {path}")
+    if len(words) > count:
+        words = words[:count]
+    return words

ttyping-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: ttyping
+Version: 0.1.0
+Summary: A minimal terminal typing test — English & Korean, monkeytype-inspired
+License: MIT
+License-File: LICENSE
+Keywords: monkeytype,terminal,textual,tui,typing
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.10
+Requires-Dist: textual>=0.40
+Description-Content-Type: text/markdown
+
+# ttyping
+
+A minimal, monkeytype-inspired terminal typing test. English & Korean.
+
+## Install
+
+```
+pip install ttyping
+```
+
+Or with uv:
+
+```
+uv tool install ttyping
+```
+
+## Usage
+
+```
+ttyping                    # English, 25 random words
+ttyping --lang ko          # Korean random words
+ttyping --file path.txt    # Practice from file
+ttyping --words 50         # Custom word count
+ttyping --time 30          # 30-second timed test
+ttyping history            # View past results
+```
+
+## Keybindings
+
+| Key   | Action         |
+|-------|----------------|
+| Tab   | Restart test   |
+| Esc   | Quit           |
+| Space | Next word      |
+
+Results are saved locally at `~/.ttyping/results.json`.

ttyping-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ttyping/__init__.py,sha256=E9Pdsw0XMEuhKdVMqp4H7miouohIjHo7HI5AO1GceIw,73
+ttyping/__main__.py,sha256=a8hwPu7I1STgyyvTkyacL8QcudUNBxIeCENG-r0at0c,1325
+ttyping/app.py,sha256=0sZ_IBGE_x_fj7xa5RK14QUcZHpeQigukUR5HG0F4Mw,1916
+ttyping/screens.py,sha256=Gr-v7O2CqYkx384Igdzfk9HSKPT8ACcy7wFJK8_5bqM,18432
+ttyping/storage.py,sha256=-Mm5E0dVi9wJa1FYD6bIsuqfXwLifQgH2W_aidwdm00,1033
+ttyping/words.py,sha256=l0LLzwDg-ojYW8rj77o4X8rz8MyY3UYVnyMy3jpoFcY,4373
+ttyping-0.1.0.dist-info/METADATA,sha256=TYPSIq7LBcJ5CbYWj-BBsTODa-oeEIZLdl8q3eF6TUk,1272
+ttyping-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ttyping-0.1.0.dist-info/entry_points.txt,sha256=QGUQo8_hblcl7egPGHAXreTOZZ-ZDxfIu9xEj3s9pLk,50
+ttyping-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ttyping-0.1.0.dist-info/RECORD,,

ttyping-0.1.0.dist-info/WHEEL

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

ttyping-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ttyping = ttyping.__main__:main

ttyping-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.