rsvp-pivot-reader 0.1.0__tar.gz

rsvp_pivot_reader-0.1.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: rsvp-pivot-reader
+Version: 0.1.0
+Summary: A Rapid Serial Visual Presentation (RSVP) speed reader with a Spritz-style center-anchored pivot-letter display, folder browser, and persistent settings
+Author: Rutvik Babar
+Maintainer: Rutvik Babar
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/RutvikBabar/RSVP-Reader
+Project-URL: Repository, https://github.com/RutvikBabar/RSVP-Reader
+Project-URL: Issues, https://github.com/RutvikBabar/RSVP-Reader/issues
+Keywords: rsvp,speed-reading,spritz,pivot,reader,tkinter,productivity
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# RSVP Pivot Reader

rsvp_pivot_reader-0.1.0/README.md

@@ -0,0 +1 @@
+# RSVP Pivot Reader

rsvp_pivot_reader-0.1.0/my_package/rsvp_pivot_reader.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: rsvp-pivot-reader
+Version: 0.1.0
+Summary: A Rapid Serial Visual Presentation (RSVP) speed reader with a Spritz-style center-anchored pivot-letter display, folder browser, and persistent settings
+Author: Rutvik Babar
+Maintainer: Rutvik Babar
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/RutvikBabar/RSVP-Reader
+Project-URL: Repository, https://github.com/RutvikBabar/RSVP-Reader
+Project-URL: Issues, https://github.com/RutvikBabar/RSVP-Reader/issues
+Keywords: rsvp,speed-reading,spritz,pivot,reader,tkinter,productivity
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# RSVP Pivot Reader

rsvp_pivot_reader-0.1.0/my_package/rsvp_pivot_reader.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+my_package/rsvp_reader.py
+my_package/rsvp_pivot_reader.egg-info/PKG-INFO
+my_package/rsvp_pivot_reader.egg-info/SOURCES.txt
+my_package/rsvp_pivot_reader.egg-info/dependency_links.txt
+my_package/rsvp_pivot_reader.egg-info/entry_points.txt
+my_package/rsvp_pivot_reader.egg-info/requires.txt
+my_package/rsvp_pivot_reader.egg-info/top_level.txt

rsvp_pivot_reader-0.1.0/my_package/rsvp_pivot_reader.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rsvp_pivot_reader-0.1.0/my_package/rsvp_pivot_reader.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gui_scripts]
+rsvp-pivot-reader = rsvp_reader:main

rsvp_pivot_reader-0.1.0/my_package/rsvp_pivot_reader.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+ruff>=0.5
+mypy>=1.10
+build>=1.2
+twine>=5.0

rsvp_pivot_reader-0.1.0/my_package/rsvp_pivot_reader.egg-info/top_level.txt

@@ -0,0 +1 @@
+rsvp_reader

rsvp_pivot_reader-0.1.0/my_package/rsvp_reader.py

@@ -0,0 +1,1077 @@
+"""
+RSVP Reader - Full Application
+--------------------------------
+Browses a book folder (with subfolders) and displays any selected .txt file
+as an RSVP reader (chunks of N words) on a fullscreen window, with a
+center-anchored pivot-letter guide box (Spritz-style) and a persistent
+settings menu.
+
+CHUNKING RULES
+1. Regular punctuation (comma, semicolon, colon, apostrophe, etc.) attaches
+   to its word and never forces an early or late break. The chunk just
+   keeps filling toward CHUNK_SIZE.
+2. A period (.) forces the current chunk to close immediately on the word
+   carrying it (chunk can end at 1, 2, or 3 words). The next word starts a
+   fresh chunk.
+3. An opening quotation mark (straight " or curly “) forces the PREVIOUS
+   chunk to close right before it, so the quoted word always starts a new
+   chunk.
+4. A closing quotation mark (straight " or curly ”) follows the same rule
+   as a period: it forces the chunk to close immediately on the word
+   carrying it.
+
+A preprocessing pass fixes glued text with no space around punctuation or
+quotes (e.g. text pasted as one line, like 'it."Believe' or 'forth,The'),
+which otherwise hides these boundaries from the chunker. Straight double
+quotes are handled with a parity tracker (1st, 3rd, 5th... occurrence is
+treated as opening; 2nd, 4th, 6th... as closing).
+
+PIVOT-LETTER HIGHLIGHT (center-anchored RSVP display)
+- Within each displayed chunk, exactly one word is the "pivot word":
+    * 3-word chunk -> the middle (2nd) word.
+    * 2-word chunk -> whichever word has more letters (ties -> first word).
+    * 1-word chunk -> that word.
+- Within the pivot word, exactly one LETTER is the "pivot letter", counting
+  only alphabetic characters (punctuation is ignored for this calculation):
+    * Odd letter-count -> the exact middle letter.
+    * Even letter-count -> the letter just left of center
+      (e.g. "Bull" -> 4 letters -> index 1 -> "u").
+- The pivot letter is rendered inside a FIXED-SIZE box (dimensions constant
+  across every chunk/letter -- sized once per render to the widest glyph
+  the current font can render -- so it never grows or shrinks
+  letter-to-letter). Two short vertical tick marks are drawn perpendicular
+  to the box, one centered just above it and one just below it (classic
+  Spritz-style guide marks), rather than horizontal bars. This pivot letter
+  is drawn at a fixed x position at the exact horizontal center of the
+  screen; the rest of the chunk's text is drawn snugly against the box's
+  left/right edges (measured by actual pixel text width), so the pivot
+  letter itself never moves on screen no matter how long or short the
+  chunk/word is, and there's minimal dead space between the box and the
+  flowing text. This is implemented with a Canvas (not a Label), since a
+  Label cannot pin one character to a fixed coordinate while text flows
+  around it. Inter-word spacing is intentionally tightened.
+- SENTENCE MODE (toggle in settings): instead of word-chunks with a pivot
+  box, the reader shows one full sentence at a time (text up to and
+  including the next period) as a single static block of text, with no
+  pivot letter/box/lines at all. Left-click/hold-to-autoplay and
+  right-click/back still work the same way, just advancing by sentence
+  instead of by chunk.
+
+SETTINGS MENU (gear icon, top-right corner)
+- Click the gear icon to open/close the settings panel directly.
+- Additionally, holding right-click for 3+ seconds anywhere in the reader
+  also opens the settings panel (a short right-click under 3 seconds still
+  just goes back one chunk/sentence as before).
+- Settings:
+    1. Chunk size: 1 or 3 words. Changing this while a book is open
+       re-chunks immediately from the current reading position (tries to
+       preserve your place in the underlying text).
+    2. Words-per-minute (WPM) autoplay rate: this is the MAXIMUM speed
+       autoplay ramps up to. Holding left-click for 2+ seconds starts
+       autoplay; it begins at a slow pace and gradually accelerates,
+       reaching the configured max WPM after 5 seconds of continuous
+       holding, then holds steady at max WPM until released. Releasing
+       the mouse button stops autoplay immediately. A short left-click
+       (under 2 seconds) just advances one chunk/sentence as normal.
+    3. Font family.
+    4. Font size.
+    5. Brightness (dims/brightens the displayed text and UI accent color).
+    6. Font color: opens the OS-native color-wheel/picker dialog
+       (tkinter.colorchooser) so the user can choose ANY color, rather than
+       being limited to a fixed swatch palette. A live preview swatch next
+       to the button shows the currently selected color.
+    7. Sentence mode on/off (see above).
+- All settings persist across sessions via a small JSON config file
+  (rsvp_settings.json) saved next to this script.
+
+NAVIGATION
+- Folder browser: left-click a folder to open it, left-click a .txt file to
+  start reading it. The current folder path is shown at the very top, with
+  a separator line beneath it; the folder/file list itself is dead-centered
+  in the remaining window space.
+- Reader:
+    * Short left-click -> forward one chunk/sentence.
+    * Left-click held 2+ seconds -> autoplay forward, ramping from a slow
+      start up to the configured max WPM over 5 seconds, until released.
+    * Short right-click -> back one chunk/sentence.
+    * Right-click held 3+ seconds -> opens the settings panel.
+- Escape goes back exactly one level (reader -> the folder it was opened
+  from -> parent folder -> ... -> root folder), using an explicit
+  navigation STACK so each press pops exactly one level. Once you are
+  already at the root folder view (nothing left to pop), Escape instead
+  shrinks the window out of fullscreen mode. Escape also closes the
+  settings panel first, if it's open.
+- 'q' quits the application from anywhere.
+
+SETUP
+- Place your book .txt files (and optional subfolders) inside a folder
+  named "book" next to this script.
+"""
+
+import os
+import re
+import json
+import string
+import tkinter as tk
+import tkinter.font as tkfont
+from tkinter import colorchooser
+
+BOOK_ROOT = "book"
+SETTINGS_PATH = "rsvp_settings.json"
+
+DEFAULT_SETTINGS = {
+    "chunk_size": 3,          # 1 or 3
+    "wpm": 300,               # this is the MAX wpm autoplay ramps up to
+    "font_family": "Consolas",
+    "font_size": 40,
+    "brightness": 100,        # 0-100 percent
+    "font_color": "#FF4500",  # base (100% brightness) accent/text color
+    "sentence_mode": False,
+}
+
+BG_COLOR = "#000000"
+PIVOT_FG_COLOR = "#FFFFFF"
+STATUS_COLOR = "#552200"
+BROWSER_FONT = ("Consolas", 20)
+HEADER_FONT = ("Consolas", 14, "bold")
+STATUS_FONT = ("Consolas", 10)
+GEAR_FONT = ("Consolas", 22)
+PANEL_LABEL_FONT = ("Consolas", 13, "bold")
+PANEL_FONT = ("Consolas", 12)
+
+STRAIGHT_QUOTE = '"'
+OPEN_CURLY = "\u201c"
+CLOSE_CURLY = "\u201d"
+OPENING_QUOTES = (STRAIGHT_QUOTE, OPEN_CURLY)
+CLOSING_QUOTES = (STRAIGHT_QUOTE, CLOSE_CURLY)
+NO_SPACE_NEEDED_AFTER = (" ", "\n", "\t", ".", ",", ";", ":", "!", "?")
+
+FONT_CHOICES = ["Consolas", "Courier New", "Georgia", "Arial", "Times New Roman", "Verdana"]
+
+# All glyphs considered when measuring the widest-possible character, so the
+# pivot box can be sized once (fixed) rather than per-letter.
+WIDTH_PROBE_CHARS = string.ascii_uppercase + string.ascii_lowercase
+
+
+# ---------------------------------------------------------------------------
+# Settings persistence
+# ---------------------------------------------------------------------------
+
+def load_settings():
+    settings = dict(DEFAULT_SETTINGS)
+    if os.path.isfile(SETTINGS_PATH):
+        try:
+            with open(SETTINGS_PATH, "r", encoding="utf-8") as f:
+                saved = json.load(f)
+            for k in DEFAULT_SETTINGS:
+                if k in saved:
+                    settings[k] = saved[k]
+        except (OSError, json.JSONDecodeError):
+            pass
+    return settings
+
+
+def save_settings(settings):
+    try:
+        with open(SETTINGS_PATH, "w", encoding="utf-8") as f:
+            json.dump(settings, f, indent=2)
+    except OSError:
+        pass
+
+
+def apply_brightness(hex_color, brightness_pct):
+    """Scales an #RRGGBB color's channels by brightness_pct (0-100)."""
+    hex_color = hex_color.lstrip("#")
+    if len(hex_color) != 6:
+        hex_color = "FF4500"
+    r = int(hex_color[0:2], 16)
+    g = int(hex_color[2:4], 16)
+    b = int(hex_color[4:6], 16)
+    scale = max(0, min(100, brightness_pct)) / 100.0
+    r = max(0, min(255, round(r * scale)))
+    g = max(0, min(255, round(g * scale)))
+    b = max(0, min(255, round(b * scale)))
+    return f"#{r:02X}{g:02X}{b:02X}"
+
+
+# ---------------------------------------------------------------------------
+# Text preprocessing / chunking (word-chunk mode)
+# ---------------------------------------------------------------------------
+
+def fix_glued_punctuation(text):
+    """
+    Inserts missing spaces around punctuation and quotes so line-wrapped or
+    single-line-pasted text doesn't hide chunk boundaries, e.g.
+    "forth,The" becomes "forth, The", and 'it."Believe' becomes 'it. "Believe'.
+
+    Uses a running parity flag to classify straight quotes as opening/closing,
+    since the same character is used for both.
+    """
+    text = text.replace("\r\n", " ").replace("\n", " ")
+    text = re.sub(r"\s+", " ", text)
+
+    out = []
+    quote_open = False
+    n = len(text)
+    i = 0
+    while i < n:
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < n else ""
+
+        if ch == STRAIGHT_QUOTE:
+            if not quote_open:
+                if out and out[-1] not in (" ",):
+                    out.append(" ")
+                out.append(ch)
+                quote_open = True
+            else:
+                out.append(ch)
+                quote_open = False
+                if nxt and nxt not in NO_SPACE_NEEDED_AFTER:
+                    out.append(" ")
+        elif ch == OPEN_CURLY:
+            if out and out[-1] not in (" ",):
+                out.append(" ")
+            out.append(ch)
+        elif ch == CLOSE_CURLY:
+            out.append(ch)
+            if nxt and nxt not in NO_SPACE_NEEDED_AFTER:
+                out.append(" ")
+        elif ch in (".", ","):
+            out.append(ch)
+            if (
+                nxt
+                and nxt not in NO_SPACE_NEEDED_AFTER
+                and nxt not in OPENING_QUOTES
+                and nxt not in CLOSING_QUOTES
+            ):
+                out.append(" ")
+        else:
+            out.append(ch)
+        i += 1
+
+    return re.sub(r"\s+", " ", "".join(out)).strip()
+
+
+def tokenize(text):
+    raw_tokens = text.split()
+    tokens = []
+    for tok in raw_tokens:
+        if not tok:
+            continue
+        if tok[0] in OPENING_QUOTES:
+            tokens.append(("OPEN_QUOTE_MARKER", tok[0]))
+            rest = tok[1:]
+            if rest:
+                tokens.append(("WORD", rest))
+        else:
+            tokens.append(("WORD", tok))
+    return tokens
+
+
+def word_ends_chunk(word):
+    """
+    A word forces the chunk to close on it if it ends with a period or a
+    closing quote (covers "word." and 'word."').
+    """
+    stripped = word.rstrip()
+    if not stripped:
+        return False
+    if stripped[-1] in CLOSING_QUOTES:
+        return True
+    if stripped.endswith("."):
+        return True
+    return False
+
+
+def build_chunks(text, chunk_size):
+    tokens = tokenize(text)
+    chunks = []
+    current = []
+
+    for kind, value in tokens:
+        if kind == "OPEN_QUOTE_MARKER":
+            if current:
+                chunks.append(" ".join(current))
+                current = []
+            current.append(value)
+            continue
+
+        word = value
+        if current and current[-1] in OPENING_QUOTES:
+            current[-1] = current[-1] + word
+        else:
+            current.append(word)
+
+        if word_ends_chunk(word):
+            chunks.append(" ".join(current))
+            current = []
+        elif len(current) >= chunk_size:
+            chunks.append(" ".join(current))
+            current = []
+
+    if current:
+        chunks.append(" ".join(current))
+
+    return chunks
+
+
+def build_sentences(text):
+    """
+    Splits cleaned text into sentences: a sentence runs up to and including
+    the next period (or closing quote immediately following a period), or
+    to the end of the text if no more periods remain.
+    """
+    tokens = tokenize(text)
+    sentences = []
+    current = []
+
+    for kind, value in tokens:
+        if kind == "OPEN_QUOTE_MARKER":
+            if not current:
+                current.append(value)
+                continue
+            current.append(value)
+            continue
+
+        word = value
+        if current and current[-1] in OPENING_QUOTES:
+            current[-1] = current[-1] + word
+        else:
+            current.append(word)
+
+        stripped = word.rstrip()
+        if stripped.endswith(".") or (
+            len(stripped) >= 2 and stripped[-1] in CLOSING_QUOTES and stripped[-2:-1] == "."
+        ):
+            sentences.append(" ".join(current))
+            current = []
+
+    if current:
+        sentences.append(" ".join(current))
+
+    return sentences
+
+
+def load_book_text(path):
+    with open(path, "r", encoding="utf-8-sig", errors="ignore") as f:
+        raw_text = f.read()
+    return fix_glued_punctuation(raw_text)
+
+
+# ---------------------------------------------------------------------------
+# Pivot-letter calculation (word-chunk mode only)
+# ---------------------------------------------------------------------------
+
+def choose_pivot_word_index(words):
+    """
+    - 3 words -> index 1 (the middle word).
+    - 2 words -> index of whichever word has the most alphabetic letters
+      (tie -> first word, index 0).
+    - 1 word -> index 0.
+    """
+    if len(words) <= 1:
+        return 0
+    if len(words) == 2:
+        letters0 = sum(1 for c in words[0] if c.isalpha())
+        letters1 = sum(1 for c in words[1] if c.isalpha())
+        return 0 if letters0 >= letters1 else 1
+    return len(words) // 2
+
+
+def choose_pivot_letter_index(word):
+    """
+    Counting only alphabetic characters:
+    - Odd letter-count -> the exact middle letter.
+    - Even letter-count -> the letter just left of center.
+    Returns None if the word has no alphabetic characters at all.
+    """
+    letter_positions = [i for i, c in enumerate(word) if c.isalpha()]
+    n = len(letter_positions)
+    if n == 0:
+        return None
+    if n % 2 == 1:
+        middle = n // 2
+    else:
+        middle = (n // 2) - 1
+    return letter_positions[middle]
+
+
+def split_chunk_for_pivot(chunk_text):
+    """
+    Returns (before_text, pivot_letter, after_text) such that
+    before_text + pivot_letter + after_text reconstructs chunk_text exactly.
+    pivot_letter is None if the chunk has no alphabetic character at all.
+    """
+    words = chunk_text.split(" ")
+    pivot_word_idx = choose_pivot_word_index(words)
+    pivot_word = words[pivot_word_idx]
+
+    letter_idx = choose_pivot_letter_index(pivot_word)
+    if letter_idx is None:
+        return chunk_text, None, ""
+
+    before_words = words[:pivot_word_idx]
+    after_words = words[pivot_word_idx + 1:]
+
+    pivot_word_before = pivot_word[:letter_idx]
+    pivot_letter = pivot_word[letter_idx]
+    pivot_word_after = pivot_word[letter_idx + 1:]
+
+    before_text = " ".join(before_words)
+    if before_text:
+        before_text += " "
+    before_text += pivot_word_before
+
+    after_text = pivot_word_after
+    if after_words:
+        after_text += " " + " ".join(after_words)
+
+    return before_text, pivot_letter, after_text
+
+
+class App:
+    def __init__(self, root, book_root=BOOK_ROOT):
+        self.root = root
+        self.book_root = book_root
+        self.settings = load_settings()
+
+        self.root.title("RSVP Reader")
+        self.root.configure(bg=BG_COLOR)
+        self.root.attributes("-fullscreen", True)
+        self.is_fullscreen = True
+
+        self.container = tk.Frame(self.root, bg=BG_COLOR)
+        self.container.pack(fill="both", expand=True)
+
+        self.nav_stack = []
+        self.settings_panel = None  # currently-open settings overlay Frame, or None
+
+        # hold-to-act timers/state, used only in the reader view
+        self._left_hold_job = None
+        self._left_autoplay_active = False
+        self._left_autoplay_job = None
+        self._left_autoplay_start_time = 0
+        self._left_autoplay_last_advance = 0
+        self._right_hold_job = None
+        self._right_settings_triggered = False
+
+        self.root.bind("<Escape>", self.on_escape)
+        self.root.bind("q", lambda e: self.root.destroy())
+
+        if not os.path.isdir(self.book_root):
+            os.makedirs(self.book_root, exist_ok=True)
+
+        self.push_folder(self.book_root)
+
+    # -- color/appearance helpers -----------------------------------------
+    def current_text_color(self):
+        return apply_brightness(self.settings["font_color"], self.settings["brightness"])
+
+    def current_reader_font(self):
+        return (self.settings["font_family"], self.settings["font_size"], "bold")
+
+    # -- navigation stack helpers -----------------------------------------
+    def push_folder(self, path):
+        self.nav_stack.append(("folder", path))
+        self.render_folder(path)
+
+    def push_reader(self, book_path):
+        self.nav_stack.append(("reader", book_path))
+        self.render_reader(book_path)
+
+    def on_escape(self, event=None):
+        if self.settings_panel is not None:
+            self.close_settings_panel()
+            return
+
+        if len(self.nav_stack) > 1:
+            self.nav_stack.pop()
+            kind, data = self.nav_stack[-1]
+            if kind == "folder":
+                self.render_folder(data)
+            else:
+                self.render_reader(data)
+            return
+
+        if self.is_fullscreen:
+            self.root.attributes("-fullscreen", False)
+            self.root.geometry("900x600")
+            self.is_fullscreen = False
+
+    def clear_container(self):
+        self.close_settings_panel()
+        for widget in self.container.winfo_children():
+            widget.destroy()
+
+    # -- gear icon (present on every view) ---------------------------------
+    def add_gear_icon(self):
+        gear = tk.Label(
+            self.container,
+            text="\u2699",
+            font=GEAR_FONT,
+            fg=self.current_text_color(),
+            bg=BG_COLOR,
+            cursor="hand2",
+        )
+        gear.place(relx=1.0, rely=0.0, x=-16, y=10, anchor="ne")
+        gear.bind("<Button-1>", lambda e: self.toggle_settings_panel())
+
+    # -- settings panel -----------------------------------------------------
+    def toggle_settings_panel(self):
+        if self.settings_panel is not None:
+            self.close_settings_panel()
+        else:
+            self.open_settings_panel()
+
+    def close_settings_panel(self):
+        if self.settings_panel is not None:
+            self.settings_panel.destroy()
+            self.settings_panel = None
+
+    def open_settings_panel(self):
+        if self.settings_panel is not None:
+            return
+
+        panel = tk.Frame(self.container, bg="#111111", highlightbackground=self.current_text_color(),
+                          highlightthickness=2)
+        panel.place(relx=1.0, rely=0.0, x=-10, y=54, anchor="ne", width=340)
+        self.settings_panel = panel
+
+        def row(label_text):
+            r = tk.Frame(panel, bg="#111111")
+            r.pack(fill="x", padx=12, pady=(10, 0))
+            tk.Label(r, text=label_text, font=PANEL_LABEL_FONT, fg=self.current_text_color(),
+                     bg="#111111", anchor="w").pack(fill="x")
+            return r
+
+        # 1) chunk size
+        r1 = row("Chunk size")
+        chunk_var = tk.IntVar(value=self.settings["chunk_size"])
+        for val in (1, 3):
+            tk.Radiobutton(
+                r1, text=f"{val} word{'s' if val > 1 else ''}", variable=chunk_var, value=val,
+                font=PANEL_FONT, fg="white", bg="#111111", selectcolor="#333333",
+                activebackground="#111111", command=lambda: self.on_chunk_size_change(chunk_var.get()),
+            ).pack(side="left", padx=(0, 10))
+
+        # 2) WPM (max autoplay speed)
+        r2 = row("Autoplay max speed (WPM)")
+        wpm_var = tk.IntVar(value=self.settings["wpm"])
+        wpm_scale = tk.Scale(
+            r2, from_=100, to=800, orient="horizontal", variable=wpm_var,
+            bg="#111111", fg="white", troughcolor="#333333", highlightthickness=0,
+            command=lambda v: self.on_wpm_change(int(float(v))),
+        )
+        wpm_scale.pack(fill="x")
+
+        # 3) font family
+        r3 = row("Font")
+        font_var = tk.StringVar(value=self.settings["font_family"])
+        font_menu = tk.OptionMenu(r3, font_var, *FONT_CHOICES, command=self.on_font_family_change)
+        font_menu.configure(bg="#333333", fg="white", highlightthickness=0)
+        font_menu["menu"].configure(bg="#333333", fg="white")
+        font_menu.pack(fill="x")
+
+        # 4) font size
+        r4 = row("Font size")
+        size_var = tk.IntVar(value=self.settings["font_size"])
+        size_scale = tk.Scale(
+            r4, from_=16, to=100, orient="horizontal", variable=size_var,
+            bg="#111111", fg="white", troughcolor="#333333", highlightthickness=0,
+            command=lambda v: self.on_font_size_change(int(float(v))),
+        )
+        size_scale.pack(fill="x")
+
+        # 5) brightness
+        r5 = row("Brightness")
+        bright_var = tk.IntVar(value=self.settings["brightness"])
+        bright_scale = tk.Scale(
+            r5, from_=10, to=100, orient="horizontal", variable=bright_var,
+            bg="#111111", fg="white", troughcolor="#333333", highlightthickness=0,
+            command=lambda v: self.on_brightness_change(int(float(v))),
+        )
+        bright_scale.pack(fill="x")
+
+        # 6) font color -- full color-wheel picker (tkinter.colorchooser)
+        # instead of a fixed swatch palette, so the user can pick ANY color.
+        r6 = row("Font color")
+        color_picker_row = tk.Frame(r6, bg="#111111")
+        color_picker_row.pack(fill="x", pady=(4, 0))
+
+        current_color_preview = tk.Label(
+            color_picker_row, text="  ", bg=self.settings["font_color"],
+            width=4, relief="ridge", bd=2,
+        )
+        current_color_preview.pack(side="left", padx=(0, 8))
+        self._color_preview_widget = current_color_preview
+
+        pick_color_btn = tk.Label(
+            color_picker_row, text="Choose color...", font=PANEL_FONT,
+            fg="black", bg="#DDDDDD", cursor="hand2", padx=8, pady=3,
+        )
+        pick_color_btn.pack(side="left", fill="x", expand=True)
+        pick_color_btn.bind("<Button-1>", lambda e: self.open_color_wheel())
+
+        # 7) sentence mode
+        r7 = row("Sentence mode")
+        sentence_var = tk.BooleanVar(value=self.settings["sentence_mode"])
+        tk.Checkbutton(
+            r7, text="Show full sentences, no pivot box", variable=sentence_var,
+            font=PANEL_FONT, fg="white", bg="#111111", selectcolor="#333333",
+            activebackground="#111111",
+            command=lambda: self.on_sentence_mode_change(sentence_var.get()),
+        ).pack(fill="x")
+
+        close_btn = tk.Label(
+            panel, text="Close", font=PANEL_FONT, fg="black", bg=self.current_text_color(),
+            cursor="hand2",
+        )
+        close_btn.pack(fill="x", padx=12, pady=12)
+        close_btn.bind("<Button-1>", lambda e: self.close_settings_panel())
+
+    def open_color_wheel(self):
+        """
+        Opens the OS-native color-wheel/picker dialog, pre-seeded with the
+        currently selected font color, and applies whatever the user picks.
+        """
+        result = colorchooser.askcolor(
+            color=self.settings["font_color"],
+            title="Choose RSVP text color",
+            parent=self.root,
+        )
+        # askcolor returns ((r, g, b), "#rrggbb") or (None, None) on cancel
+        if result and result[1]:
+            self.on_font_color_change(result[1])
+
+    # -- settings change handlers ------------------------------------------
+    def _save(self):
+        save_settings(self.settings)
+
+    def _current_reader_state(self):
+        """Returns (book_path, state_dict) if a reader view is currently on top, else (None, None)."""
+        if self.nav_stack and self.nav_stack[-1][0] == "reader":
+            return self.nav_stack[-1][1], getattr(self, "_reader_state", None)
+        return None, None
+
+    def on_chunk_size_change(self, new_size):
+        self.settings["chunk_size"] = new_size
+        self._save()
+        book_path, state = self._current_reader_state()
+        if book_path and state is not None:
+            self.rechunk_current_reader(book_path, state)
+
+    def on_wpm_change(self, new_wpm):
+        self.settings["wpm"] = max(1, new_wpm)
+        self._save()
+
+    def on_font_family_change(self, new_family):
+        self.settings["font_family"] = new_family
+        self._save()
+        self.refresh_reader_visuals()
+
+    def on_font_size_change(self, new_size):
+        self.settings["font_size"] = new_size
+        self._save()
+        self.refresh_reader_visuals()
+
+    def on_brightness_change(self, new_brightness):
+        self.settings["brightness"] = new_brightness
+        self._save()
+        self.refresh_reader_visuals()
+
+    def on_font_color_change(self, new_color):
+        self.settings["font_color"] = new_color
+        self._save()
+        self.refresh_reader_visuals()
+        if hasattr(self, "_color_preview_widget") and self._color_preview_widget is not None:
+            try:
+                self._color_preview_widget.configure(bg=new_color)
+            except tk.TclError:
+                pass
+
+    def on_sentence_mode_change(self, enabled):
+        self.settings["sentence_mode"] = enabled
+        self._save()
+        book_path, state = self._current_reader_state()
+        if book_path and state is not None:
+            self.rechunk_current_reader(book_path, state)
+
+    def refresh_reader_visuals(self):
+        book_path, state = self._current_reader_state()
+        if book_path and state is not None and hasattr(self, "_reader_show_chunk"):
+            self._reader_show_chunk()
+        if hasattr(self, "_reader_gear_widget") and self._reader_gear_widget is not None:
+            self._reader_gear_widget.configure(fg=self.current_text_color())
+
+    def rechunk_current_reader(self, book_path, state):
+        """
+        Re-derives chunks/sentences using the current settings, trying to keep
+        the reading position at (approximately) the same point in the text.
+        """
+        old_units = state["chunks"]
+        old_idx = state["index"]
+        chars_before = sum(len(u) + 1 for u in old_units[:old_idx])
+
+        full_text = state["full_text"]
+        if self.settings["sentence_mode"]:
+            new_units = build_sentences(full_text)
+        else:
+            new_units = build_chunks(full_text, self.settings["chunk_size"])
+
+        running = 0
+        new_idx = 0
+        for i, u in enumerate(new_units):
+            if running >= chars_before:
+                new_idx = i
+                break
+            running += len(u) + 1
+        else:
+            new_idx = max(0, len(new_units) - 1)
+
+        state["chunks"] = new_units
+        state["index"] = min(new_idx, max(0, len(new_units) - 1))
+        if hasattr(self, "_reader_show_chunk"):
+            self._reader_show_chunk()
+
+    # -- folder browser view ------------------------------------------------
+    def render_folder(self, path):
+        self.clear_container()
+
+        rel_path = os.path.relpath(path, self.book_root)
+        display_path = "book" if rel_path == "." else f"book/{rel_path}"
+
+        header = tk.Label(
+            self.container,
+            text=display_path,
+            font=HEADER_FONT,
+            fg=self.current_text_color(),
+            bg=BG_COLOR,
+        )
+        header.pack(side="top", pady=(20, 4))
+
+        separator = tk.Frame(self.container, bg=self.current_text_color(), height=2)
+        separator.pack(side="top", fill="x", padx=40, pady=(0, 10))
+
+        list_frame = tk.Frame(self.container, bg=BG_COLOR)
+        list_frame.place(relx=0.5, rely=0.5, anchor="center")
+
+        try:
+            entries = sorted(os.listdir(path))
+        except OSError:
+            entries = []
+
+        folders = [e for e in entries if os.path.isdir(os.path.join(path, e))]
+        books = [e for e in entries if e.lower().endswith(".txt")]
+
+        if not folders and not books:
+            empty = tk.Label(
+                list_frame,
+                text="(empty folder)",
+                font=BROWSER_FONT,
+                fg=self.current_text_color(),
+                bg=BG_COLOR,
+            )
+            empty.pack(pady=10)
+
+        for name in folders:
+            full_path = os.path.join(path, name)
+            lbl = tk.Label(
+                list_frame,
+                text=f"[Folder] {name}",
+                font=BROWSER_FONT,
+                fg=self.current_text_color(),
+                bg=BG_COLOR,
+                cursor="hand2",
+            )
+            lbl.pack(pady=4)
+            lbl.bind("<Button-1>", lambda e, p=full_path: self.push_folder(p))
+
+        for name in books:
+            full_path = os.path.join(path, name)
+            lbl = tk.Label(
+                list_frame,
+                text=f"[Book] {name}",
+                font=BROWSER_FONT,
+                fg=self.current_text_color(),
+                bg=BG_COLOR,
+                cursor="hand2",
+            )
+            lbl.pack(pady=4)
+            lbl.bind("<Button-1>", lambda e, p=full_path: self.push_reader(p))
+
+        self.add_gear_icon()
+
+    # -- reader view ----------------------------------------------------------
+    def render_reader(self, book_path):
+        self.clear_container()
+
+        full_text = load_book_text(book_path)
+        if self.settings["sentence_mode"]:
+            units = build_sentences(full_text)
+        else:
+            units = build_chunks(full_text, self.settings["chunk_size"])
+
+        state = {"index": 0, "chunks": units, "full_text": full_text}
+        self._reader_state = state
+
+        screen_w = self.root.winfo_screenwidth()
+        screen_h = self.root.winfo_screenheight()
+
+        canvas = tk.Canvas(
+            self.container,
+            width=screen_w,
+            height=screen_h,
+            bg=BG_COLOR,
+            highlightthickness=0,
+        )
+        canvas.place(x=0, y=0, relwidth=1, relheight=1)
+
+        status_label = tk.Label(
+            self.container,
+            text="",
+            font=STATUS_FONT,
+            fg=STATUS_COLOR,
+            bg=BG_COLOR,
+        )
+        status_label.place(relx=0.5, rely=0.97, anchor="center")
+
+        center_x = screen_w // 2
+        center_y = screen_h // 2
+
+        PIVOT_PAD_X = 2         # minimal horizontal padding inside the box
+        PIVOT_PAD_Y = 2
+        TICK_GAP = 4            # gap between box edge and the start of each tick mark
+        TICK_LENGTH = 14        # length of each perpendicular (vertical) tick mark
+        WORD_SPACING_REDUCTION = 6
+        GAP_TO_PIVOT_BOX = 0    # flowing text sits flush against the box edge
+        SENTENCE_WRAP_FRAC = 0.8
+
+        def get_reader_font():
+            return tkfont.Font(root=self.root, font=self.current_reader_font())
+
+        def compute_fixed_pivot_box_width(reader_font):
+            """
+            The pivot box must never change size between letters/chunks, so we
+            measure the widest glyph the current font can render (over a fixed
+            probe set) every time show_chunk() runs, and use that as the box's
+            fixed inner width -- constant regardless of which letter is
+            actually being highlighted.
+            """
+            return max(reader_font.measure(c) for c in WIDTH_PROBE_CHARS)
+
+        def draw_flow_text(canvas_, reader_font, text_color, x, y, text, anchor_right):
+            if text == "":
+                return
+            words = text.split(" ")
+            widths = [reader_font.measure(w) for w in words]
+            space_w = max(reader_font.measure(" ") - WORD_SPACING_REDUCTION, 2)
+            total_w = sum(widths) + space_w * (len(words) - 1 if len(words) > 1 else 0)
+            cursor = (x - total_w) if anchor_right else x
+            for i, w in enumerate(words):
+                canvas_.create_text(
+                    cursor, y, text=w, anchor="nw",
+                    font=self.current_reader_font(), fill=text_color,
+                )
+                cursor += widths[i]
+                if i < len(words) - 1:
+                    cursor += space_w
+
+        def show_chunk():
+            idx = state["index"]
+            if not (0 <= idx < len(state["chunks"])):
+                return
+
+            canvas.delete("all")
+            unit_text = state["chunks"][idx]
+            text_color = self.current_text_color()
+            reader_font = get_reader_font()
+
+            if self.settings["sentence_mode"]:
+                canvas.create_text(
+                    center_x, center_y, text=unit_text,
+                    font=self.current_reader_font(), fill=text_color, anchor="center",
+                    width=int(screen_w * SENTENCE_WRAP_FRAC), justify="center",
+                )
+            else:
+                before_text, pivot_letter, after_text = split_chunk_for_pivot(unit_text)
+
+                if pivot_letter is None:
+                    canvas.create_text(
+                        center_x, center_y, text=before_text,
+                        font=self.current_reader_font(), fill=text_color, anchor="center",
+                    )
+                else:
+                    ascent = reader_font.metrics("ascent")
+                    descent = reader_font.metrics("descent")
+                    text_h = ascent + descent
+
+                    fixed_box_w = compute_fixed_pivot_box_width(reader_font)
+
+                    box_left = center_x - fixed_box_w / 2 - PIVOT_PAD_X
+                    box_right = center_x + fixed_box_w / 2 + PIVOT_PAD_X
+                    box_top = center_y - text_h / 2 - PIVOT_PAD_Y
+                    box_bottom = center_y + text_h / 2 + PIVOT_PAD_Y
+
+                    canvas.create_line(
+                        center_x, box_top - TICK_GAP,
+                        center_x, box_top - TICK_GAP - TICK_LENGTH,
+                        fill=text_color, width=2,
+                    )
+                    canvas.create_line(
+                        center_x, box_bottom + TICK_GAP,
+                        center_x, box_bottom + TICK_GAP + TICK_LENGTH,
+                        fill=text_color, width=2,
+                    )
+
+                    canvas.create_rectangle(
+                        box_left, box_top, box_right, box_bottom,
+                        fill=text_color, outline=text_color,
+                    )
+                    canvas.create_text(
+                        center_x, center_y, text=pivot_letter,
+                        font=self.current_reader_font(), fill=PIVOT_FG_COLOR, anchor="center",
+                    )
+                    draw_flow_text(
+                        canvas, reader_font, text_color,
+                        box_left - GAP_TO_PIVOT_BOX, center_y - text_h / 2,
+                        before_text, anchor_right=True,
+                    )
+                    draw_flow_text(
+                        canvas, reader_font, text_color,
+                        box_right + GAP_TO_PIVOT_BOX, center_y - text_h / 2,
+                        after_text, anchor_right=False,
+                    )
+
+            unit_label = "Sentence" if self.settings["sentence_mode"] else "Chunk"
+            wpm_suffix = ""
+            if self._left_autoplay_active:
+                wpm_suffix = f" | ~{int(self._current_ramped_wpm())} WPM (ramping to {self.settings['wpm']})"
+            status_label.config(
+                text=f"{os.path.basename(book_path)} | {unit_label} {idx + 1} / {len(state['chunks'])}"
+                     f"{wpm_suffix}"
+            )
+
+        self._reader_show_chunk = show_chunk
+
+        def advance_one(forward=True):
+            if forward:
+                if state["index"] < len(state["chunks"]) - 1:
+                    state["index"] += 1
+                    show_chunk()
+            else:
+                if state["index"] > 0:
+                    state["index"] -= 1
+                    show_chunk()
+
+        # -- left click / hold-to-autoplay (gradual ramp-up to max WPM) ------
+        RAMP_DURATION_MS = 5000       # time to reach max configured WPM
+        RAMP_START_DIVISOR = 6        # starting speed = max_wpm / this divisor
+        RAMP_MIN_START_WPM = 60       # never start slower than this
+        RAMP_TICK_MS = 100            # how often we recompute the current speed
+
+        def current_ramped_wpm():
+            max_wpm = max(1, self.settings["wpm"])
+            start_wpm = max(RAMP_MIN_START_WPM, max_wpm / RAMP_START_DIVISOR)
+            start_wpm = min(start_wpm, max_wpm)
+            now_ms = self.root.tk.call("clock", "milliseconds")
+            elapsed_ms = now_ms - self._left_autoplay_start_time
+            progress = min(1.0, max(0.0, elapsed_ms / RAMP_DURATION_MS))
+            return start_wpm + (max_wpm - start_wpm) * progress
+
+        self._current_ramped_wpm = current_ramped_wpm
+
+        def stop_autoplay():
+            self._left_autoplay_active = False
+            if self._left_autoplay_job is not None:
+                self.root.after_cancel(self._left_autoplay_job)
+                self._left_autoplay_job = None
+
+        def autoplay_tick():
+            if not self._left_autoplay_active:
+                return
+            if state["index"] >= len(state["chunks"]) - 1:
+                stop_autoplay()
+                return
+
+            now_ms = self.root.tk.call("clock", "milliseconds")
+            wpm_now = current_ramped_wpm()
+            interval_ms = max(1, int(60000 / max(1, wpm_now)))
+
+            if now_ms - self._left_autoplay_last_advance >= interval_ms:
+                advance_one(forward=True)
+                self._left_autoplay_last_advance = now_ms
+            else:
+                show_chunk()  # refresh status bar WPM readout even without advancing
+
+            self._left_autoplay_job = self.root.after(RAMP_TICK_MS, autoplay_tick)
+
+        def start_autoplay():
+            self._left_hold_job = None
+            self._left_autoplay_active = True
+            now_ms = self.root.tk.call("clock", "milliseconds")
+            self._left_autoplay_start_time = now_ms
+            self._left_autoplay_last_advance = now_ms
+            advance_one(forward=True)
+            self._left_autoplay_job = self.root.after(RAMP_TICK_MS, autoplay_tick)
+
+        def on_left_press(event):
+            stop_autoplay()
+            if self._left_hold_job is not None:
+                self.root.after_cancel(self._left_hold_job)
+            self._left_hold_job = self.root.after(2000, start_autoplay)
+
+        def on_left_release(event):
+            if self._left_hold_job is not None:
+                self.root.after_cancel(self._left_hold_job)
+                self._left_hold_job = None
+            if self._left_autoplay_active:
+                stop_autoplay()
+                show_chunk()
+            else:
+                advance_one(forward=True)
+
+        # -- right click / hold-to-open-settings ------------------------------
+        def open_settings_from_hold():
+            self._right_hold_job = None
+            self._right_settings_triggered = True
+            self.open_settings_panel()
+
+        def on_right_press(event):
+            self._right_settings_triggered = False
+            if self._right_hold_job is not None:
+                self.root.after_cancel(self._right_hold_job)
+            self._right_hold_job = self.root.after(3000, open_settings_from_hold)
+
+        def on_right_release(event):
+            if self._right_hold_job is not None:
+                self.root.after_cancel(self._right_hold_job)
+                self._right_hold_job = None
+            if not self._right_settings_triggered:
+                advance_one(forward=False)
+
+        canvas.bind("<ButtonPress-1>", on_left_press)
+        canvas.bind("<ButtonRelease-1>", on_left_release)
+        canvas.bind("<ButtonPress-3>", on_right_press)
+        canvas.bind("<ButtonRelease-3>", on_right_release)
+        self.container.bind("<ButtonPress-1>", on_left_press)
+        self.container.bind("<ButtonRelease-1>", on_left_release)
+        self.container.bind("<ButtonPress-3>", on_right_press)
+        self.container.bind("<ButtonRelease-3>", on_right_release)
+
+        show_chunk()
+        self.add_gear_icon()
+        # keep a handle to the gear widget for live-recoloring on settings change
+        for w in self.container.winfo_children():
+            if isinstance(w, tk.Label) and w.cget("text") == "\u2699":
+                self._reader_gear_widget = w
+
+
+def main():
+    root = tk.Tk()
+    App(root)
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    main()

rsvp_pivot_reader-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rsvp-pivot-reader"
+version = "0.1.0"
+description = "A Rapid Serial Visual Presentation (RSVP) speed reader with a Spritz-style center-anchored pivot-letter display, folder browser, and persistent settings"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Rutvik Babar" }]
+maintainers = [{ name = "Rutvik Babar" }]
+keywords = ["rsvp", "speed-reading", "spritz", "pivot", "reader", "tkinter", "productivity"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Text Processing",
+    "Topic :: Utilities",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.5",
+    "mypy>=1.10",
+    "build>=1.2",
+    "twine>=5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/RutvikBabar/RSVP-Reader"
+Repository = "https://github.com/RutvikBabar/RSVP-Reader"
+Issues = "https://github.com/RutvikBabar/RSVP-Reader/issues"
+
+[project.gui-scripts]
+rsvp-pivot-reader = "rsvp_reader:main"
+
+[tool.setuptools]
+package-dir = { "" = "my_package" }
+py-modules = ["rsvp_reader"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "W"]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["my_package/rsvp_reader.py"]
+ignore_missing_imports = true

rsvp_pivot_reader-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+