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

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

@@ -61,6 +61,13 @@ This project follows [Semantic Versioning](https://semver.org/).
   `DemoApp`/`DemoScreen`.
 
 ### Fixed
+- Navigation keys are responsive again. 2.0.0 made every body row pass through
+  wide-character-aware `textwidth.truncate()`, which ran three `unicodedata`
+  lookups per character on every full redraw; a 2,000-row screen spent ~39 ms
+  of a ~41 ms frame there. Printable ASCII now takes a direct one-cell path,
+  repeated `string_width()`/`truncate()` calls are memoised (a TUI redraws the
+  same rows on each keypress), and non-ASCII glyph widths are cached. The same
+  headless redraw is now ~4 ms, including mixed `✔`/`─`/`◆` rows.
 - 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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: console-window
-Version: 2.0.0
+Version: 2.0.0.1
 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.1}/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.1"
 
 from .context import Context
 from .header import HeaderLine, Span

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import unicodedata
+from functools import lru_cache
 
 __all__ = [
     'cell_to_index',
@@ -20,9 +21,21 @@ __all__ = [
 _ZERO_WIDTH_CATEGORIES = frozenset({'Mn', 'Me', 'Cf', 'Cc'})
 
 
-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,13 +45,33 @@ def char_width(ch: str) -> int:
     return 1
 
 
+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)
+
+
+# A TUI redraws the same body rows on every keypress, so these pure functions
+# otherwise repeat the same unicode scan for every navigation key.  Bounded
+# caches turn that into a dict hit while keeping memory predictable.
+@lru_cache(maxsize=4096)
 def string_width(text: str) -> int:
+    if _is_plain_ascii(text):
+        return len(text)
     return sum(char_width(ch) for ch in text)
 
 
+@lru_cache(maxsize=4096)
 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)
@@ -61,6 +94,8 @@ 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)

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

@@ -41,6 +41,27 @@ 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.string_width.cache_clear()
+    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