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

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

@@ -61,13 +61,16 @@ 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.
+- 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.1 → console_window-2.0.0.2}/PKG-INFO

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

{console_window-2.0.0.1 → 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.1 → console_window-2.0.0.2}/console_window/textwidth.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 import unicodedata
 from functools import lru_cache
 
@@ -20,6 +21,11 @@ __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 _is_plain_ascii(text: str) -> bool:
     # Fast path for the overwhelmingly common terminal case.  Printable ASCII
@@ -56,28 +62,44 @@ def char_width(ch: str) -> int:
     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)
+    # 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
 
 
@@ -97,11 +119,20 @@ def cell_to_index(text: str, col: int) -> int:
     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.1 → console_window-2.0.0.2}/tests/test_textwidth.py

@@ -56,7 +56,6 @@ def test_ascii_fast_path_skips_unicodedata(monkeypatch):
     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'