console-window 2.0.0__tar.gz → 2.0.0.2__tar.gz

{console_window-2.0.0 → console_window-2.0.0.2}/CHANGELOG.md

@@ -61,6 +61,16 @@ This project follows [Semantic Versioning](https://semver.org/).
   `DemoApp`/`DemoScreen`.
 
 ### Fixed
+- Navigation keys are responsive again. Two 2.0.0 hot paths made a full
+  redraw of a large list far slower than 1.4.3. `textwidth.truncate()` ran
+  three `unicodedata` lookups per character on every row, and
+  `Context.__init__()` ran `difflib.get_close_matches()` for every custom
+  keyword on every row (a 9,000-row screen constructs 9,000 Contexts per
+  frame). Printable ASCII now takes a direct one-cell path, mixed text skips
+  whole ASCII runs and visits only the glyphs that differ, `truncate()` uses a
+  frame-sized cache, non-ASCII glyph widths are cached, and the Context typo
+  suggestion is cached per attribute name. On vappman's 9,035-row screen,
+  `draw_screen()` fell from ~225 ms to ~74 ms (1.4.3 measured ~58 ms).
 - Hygiene debt from AUDIT.md §3.14: removed blank lines inside the
   `index_at_cell()`/`answer()` signatures and the commented-out assignment in
   `fix_positions()`; replaced `render()`'s `print()`/`except Exception` failure

{console_window-2.0.0 → console_window-2.0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: console-window
-Version: 2.0.0
+Version: 2.0.0.2
 Summary: A robust curses wrapper for creating Text User Interfaces (TUIs).
 Author-email: Joe Defen <joedef@duck.com>
 Requires-Python: >=3.10

{console_window-2.0.0 → console_window-2.0.0.2}/console_window/__init__.py

@@ -1,6 +1,6 @@
 # Single source of truth for the package version: pyproject.toml declares
 # ``dynamic = ["version"]``, so flit reads this value instead of duplicating it.
-__version__ = "2.0.0"
+__version__ = "2.0.0.2"
 
 from .context import Context
 from .header import HeaderLine, Span

{console_window-2.0.0 → console_window-2.0.0.2}/console_window/context.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import difflib
 import warnings
+from functools import lru_cache
 from typing import TYPE_CHECKING, ClassVar
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
@@ -27,11 +28,20 @@ class Context:
         # known attribute (e.g. 'abutt' for 'abut'): such a name would otherwise
         # be attached silently and never read by the engine.
         for key, value in kwargs.items():
-            near = difflib.get_close_matches(key, self.KNOWN_ATTRS, n=1, cutoff=0.8)
-            if near:
+            near = _near_miss(key, self.KNOWN_ATTRS)
+            if near is not None:
                 warnings.warn(
                     f'Context: unknown attribute {key!r} closely matches '
-                    f'{near[0]!r} (did you mean {near[0]!r}?)',
+                    f'{near!r} (did you mean {near!r}?)',
                     stacklevel=2,
                 )
             setattr(self, key, value)
+
+
+@lru_cache(maxsize=256)
+def _near_miss(key: str, known_attrs: frozenset[str]) -> str | None:
+    # Advisory typo detection only depends on the attribute name, not its value.
+    # Apps construct one Context per row, so without this cache difflib scans
+    # the same custom names thousands of times per redraw (info, item, ...).
+    matches = difflib.get_close_matches(key, known_attrs, n=1, cutoff=0.8)
+    return matches[0] if matches else None

{console_window-2.0.0 → console_window-2.0.0.2}/console_window/textwidth.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import re
 import unicodedata
+from functools import lru_cache
 
 __all__ = [
     'cell_to_index',
@@ -19,10 +21,27 @@ __all__ = [
 # characters (ZWJ, variation selectors, BOM, …) and control characters.
 _ZERO_WIDTH_CATEGORIES = frozenset({'Mn', 'Me', 'Cf', 'Cc'})
 
+# Any character that is not printable ASCII needs per-character measurement.
+# Everything else is exactly one cell wide, so measurement can skip whole
+# ASCII runs in C and only visit the glyphs that actually differ.
+_SPECIAL_CHAR = re.compile(r'[^\x20-\x7e]')
 
-def char_width(ch: str) -> int:
-    if not ch:
-        return 0
+
+def _is_plain_ascii(text: str) -> bool:
+    # Fast path for the overwhelmingly common terminal case.  Printable ASCII
+    # occupies exactly one cell per code point, so the per-character
+    # unicodedata scan in char_width() can be skipped entirely.  Control
+    # characters are excluded because this module treats them as zero-width.
+    # The checks themselves are C-level string scans, and keep add_body() on
+    # the same cost profile as the pre-2.0 plain slicing it replaced.
+    return text.isascii() and text.isprintable()
+
+
+@lru_cache(maxsize=4096)
+def _non_ascii_char_width(ch: str) -> int:
+    # Only reached for non-printable-ASCII characters.  A terminal UI reuses a
+    # small alphabet (box drawing, check marks, CJK, emoji), so caching turns
+    # the three unicodedata lookups into one dict hit after the first sighting.
     if unicodedata.combining(ch):
         return 0
     if unicodedata.category(ch) in _ZERO_WIDTH_CATEGORIES:
@@ -32,19 +51,55 @@ def char_width(ch: str) -> int:
     return 1
 
 
-def string_width(text: str) -> int:
-    return sum(char_width(ch) for ch in text)
+def char_width(ch: str) -> int:
+    if not ch:
+        return 0
+    # Printable ASCII is one cell.  This branch is what keeps mixed text (the
+    # common case: ASCII rows with a ✔/─/◆ glyph) from paying unicodedata
+    # costs for every ordinary character.
+    if ' ' <= ch <= '~':
+        return 1
+    return _non_ascii_char_width(ch)
 
 
+def string_width(text: str) -> int:
+    if _is_plain_ascii(text):
+        return len(text)
+    # Count printable ASCII as one cell, then adjust only the glyphs that
+    # differ (wide, combining, ZWJ, control).  This keeps mixed rows cheap
+    # without needing a whole-string cache large enough for every body row.
+    width = len(text)
+    for match in _SPECIAL_CHAR.finditer(text):
+        width += char_width(match.group()) - 1
+    return width
+
+
+# A redraw usually re-measures the same rows.  The cache must hold a whole
+# frame, not just a terminal's worth: large package/app lists routinely exceed
+# a few thousand rows, and a too-small cache evicts every entry before the next
+# frame and then pays both the scan and the eviction cost.  The ASCII-run scan
+# below still handles lists larger than this cap efficiently.
+@lru_cache(maxsize=32768)
 def truncate(text: str, max_width: int) -> str:
     if max_width <= 0:
         return ''
+    if _is_plain_ascii(text):
+        return text if len(text) <= max_width else text[:max_width]
     total = 0
-    for i, ch in enumerate(text):
-        w = char_width(ch)
+    ascii_start = 0
+    for match in _SPECIAL_CHAR.finditer(text):
+        run = match.start() - ascii_start
+        if total + run > max_width:
+            return text[:ascii_start + max_width - total]
+        total += run
+        w = char_width(match.group())
         if total + w > max_width:
-            return text[:i]
+            return text[:match.start()]
         total += w
+        ascii_start = match.end()
+    run = len(text) - ascii_start
+    if total + run > max_width:
+        return text[:ascii_start + max_width - total]
     return text
 
 
@@ -61,12 +116,23 @@ def rjust(text: str, width: int) -> str:
 def cell_to_index(text: str, col: int) -> int:
     if col <= 0:
         return 0
+    if _is_plain_ascii(text):
+        return min(col, len(text))
     total = 0
-    for i, ch in enumerate(text):
-        w = char_width(ch)
+    ascii_start = 0
+    for match in _SPECIAL_CHAR.finditer(text):
+        run = match.start() - ascii_start
+        if total + run > col:
+            return ascii_start + col - total
+        total += run
+        w = char_width(match.group())
         if total + w > col:
-            return i
+            return match.start()
         total += w
+        ascii_start = match.end()
+    run = len(text) - ascii_start
+    if total + run > col:
+        return ascii_start + col - total
     return len(text)
 
 

{console_window-2.0.0 → console_window-2.0.0.2}/tests/test_textwidth.py

@@ -41,6 +41,26 @@ def test_truncate_narrow():
     assert tw.truncate('abc', 10) == 'abc'
 
 
+def test_ascii_fast_path_keeps_control_chars_zero_width():
+    # Printable ASCII takes the fast path; control characters must still fall
+    # back to the unicodedata rules and occupy no cells.
+    assert tw.string_width('a\tb') == 2
+    assert tw.truncate('a\tb', 10) == 'a\tb'
+    assert tw.cell_to_index('a\tb', 1) == 2
+
+
+def test_ascii_fast_path_skips_unicodedata(monkeypatch):
+    def unexpected(ch):
+        raise AssertionError(f'unicodedata called for ASCII {ch!r}')
+
+    monkeypatch.setattr(tw.unicodedata, 'combining', unexpected)
+    monkeypatch.setattr(tw.unicodedata, 'category', unexpected)
+    monkeypatch.setattr(tw.unicodedata, 'east_asian_width', unexpected)
+    tw.truncate.cache_clear()
+    assert tw.string_width('plain ascii') == 11
+    assert tw.truncate('plain ascii', 5) == 'plain'
+
+
 def test_truncate_never_splits_wide_char():
     # 3 cells can hold one wide (2) char but not two (4).
     assert tw.truncate(CJK * 2, 3) == CJK