console-window 2.0.0.7__tar.gz → 2.0.0.8__tar.gz

{console_window-2.0.0.7 → console_window-2.0.0.8}/CHANGELOG.md

@@ -135,6 +135,16 @@ This project follows [Semantic Versioning](https://semver.org/).
   No in-repo code used it.
 
 ### Fixed
+- `win._start_curses()` once again *reattaches* the window.  The 1.4.x
+  compatibility hook is still called in the wild (psistat's "dump event log"
+  path uses `self.window._start_curses()` to return from shell mode), but the
+  2.0 implementation only created and returned a screen, leaving `win.scr` as
+  `None`; the next `clear()`/`render()` then raised
+  `AttributeError: 'NoneType' object has no attribute 'clear'`.  It now resumes
+  a suspended window through `resume_curses()` (singleton mode reattaches every
+  window sharing the screen), so the pads and the content model survive, and
+  `clear()` while suspended resets the content model without dereferencing the
+  missing screen.
 - Starting a window on a terminal with fewer than 256 colours (including tmux's
   stock `TERM=screen`, whose terminfo entry has 8 colours) no longer crashes with
   `ValueError: Color number is greater than COLORS-1`. Theme installation now

{console_window-2.0.0.7 → console_window-2.0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: console-window
-Version: 2.0.0.7
+Version: 2.0.0.8
 Summary: A robust curses wrapper for creating Text User Interfaces (TUIs).
 Author-email: Joe Defen <joedef@duck.com>
 Requires-Python: >=3.10
@@ -223,6 +223,9 @@ screen handle, backend, dimensions, pad backgrounds and redraw bookkeeping.
 In singleton mode `suspend_curses()` suspends every window that shares the
 screen, and `resume_curses()` reattaches all of them. The legacy pair works the
 same way there: `ConsoleWindow.stop_curses(); ...; ConsoleWindow.start_curses()`.
+The pre-2.0 instance hook `win._start_curses()` is also supported: it reattaches
+that window (resuming a suspended screen) and returns the live screen, so the
+old `win.stop_curses(); ...; win._start_curses()` sequence keeps working.
 Only `stop_all()` is a permanent teardown.
 
 The first successful construction latches the mode for the whole process.

{console_window-2.0.0.7 → console_window-2.0.0.8}/README.md

@@ -204,6 +204,9 @@ screen handle, backend, dimensions, pad backgrounds and redraw bookkeeping.
 In singleton mode `suspend_curses()` suspends every window that shares the
 screen, and `resume_curses()` reattaches all of them. The legacy pair works the
 same way there: `ConsoleWindow.stop_curses(); ...; ConsoleWindow.start_curses()`.
+The pre-2.0 instance hook `win._start_curses()` is also supported: it reattaches
+that window (resuming a suspended screen) and returns the live screen, so the
+old `win.stop_curses(); ...; win._start_curses()` sequence keeps working.
 Only `stop_all()` is a permanent teardown.
 
 The first successful construction latches the mode for the whole process.

{console_window-2.0.0.7 → console_window-2.0.0.8}/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.7"
+__version__ = "2.0.0.8"
 
 from .context import Context
 from .header import HeaderLine, Span

{console_window-2.0.0.7 → console_window-2.0.0.8}/console_window/window.py

@@ -291,7 +291,7 @@ class ConsoleWindow:
             self._backend = ConsoleWindow._static_backend or self._backend
             self.scr = ConsoleWindow.static_scr
         else:
-            self.scr = self._start_curses()
+            self.scr = self._new_screen()
             if self.singleton:
                 ConsoleWindow.static_scr = self.scr
                 ConsoleWindow._static_backend = self._backend
@@ -581,9 +581,42 @@ class ConsoleWindow:
 
         return True
 
-    def _start_curses(self) -> CursesSurface:
+    def _new_screen(self) -> CursesSurface:
+        """Create and initialise a brand-new screen for this window."""
         return self._init_screen(self._backend, self.theme)
 
+    def _start_curses(self) -> CursesSurface:
+        """Re-enter curses for this window and return the live screen.
+
+        Pre-2.0 exposed ``_start_curses()`` as the "come back after
+        ``stop_curses()``" call, and applications (psistat among them) kept
+        calling it on the instance.  It therefore has to *reattach* the
+        window, not merely create a screen: the old implementation returned a
+        fresh screen without storing it, so ``self.scr`` stayed ``None`` and
+        the first ``clear()``/``render()`` after returning from shell mode
+        raised ``AttributeError: 'NoneType' object has no attribute 'clear'``.
+
+        A suspended window resumes through :meth:`resume_curses` (in singleton
+        mode that reattaches every window sharing the screen), so the pads and
+        the content model survive.  ``start_curses()`` remains the class-level
+        entry point for both models.
+        """
+        if self.suspended:
+            scr = self.resume_curses()
+            if scr is not None:
+                return scr
+        if self.scr is not None:
+            return self.scr
+        # Not suspended but screen-less: restart a screen and attach this
+        # window to it.  Singleton mode owns a process-wide screen, so reuse the
+        # class-level starter; per-instance windows create their own.
+        scr = ConsoleWindow.start_curses() if self.singleton else self._new_screen()
+        if self.scr is None:  # start_curses() may have reattached it already
+            backend = (ConsoleWindow._static_backend if self.singleton else None) \
+                or self._backend
+            self._attach_screen(scr, backend)
+        return scr
+
     def _attach_screen(self, scr: CursesSurface, backend: RenderBackend) -> None:
         """Point this window at a (re)started screen and force a full repaint.
 
@@ -2149,7 +2182,12 @@ class ConsoleWindow:
         pad.refresh(scroll_top, 0, row0 + 1, col0 + 1, row0 + visible_rows, col9 - 1)
 
     def clear(self) -> None:
-        self.scr.clear()
+        # A suspended window has no screen handle until resume_curses()/
+        # start_curses(); the content model still has to be reset so the next
+        # repaint is complete.  Calling clear() while suspended used to raise
+        # AttributeError on self.scr.
+        if self.scr is not None:
+            self.scr.clear()
         # Viewport-sized pads: clearing costs one screenful, not one high-water
         # mark, and no shrink/grow decision is needed at a frame boundary.
         self.head.pad.clear()

{console_window-2.0.0.7 → console_window-2.0.0.8}/tests/test_backend.py

@@ -355,6 +355,84 @@ def test_per_instance_suspend_and_resume_curses():
     assert win not in ConsoleWindow.active_windows()
 
 
+def test_clear_while_suspended_only_resets_the_content_model():
+    # A suspended window has no screen, but clear() must still work: the next
+    # repaint after resume comes from the content model, not a stale screen.
+    backend = HeadlessBackend()
+    win = _make(backend)
+    try:
+        win.add_body('old row')
+        win.suspend_curses()
+        win.clear()  # regression: raised AttributeError on self.scr
+        assert win.body.texts == []
+        assert win.scr is None
+        win.add_body('new row')
+        scr = win._start_curses()
+        assert win.scr is scr
+        assert win.body.texts == ['new row']
+        win.clear()  # the live screen is cleared again
+        assert scr.calls_named('clear')
+    finally:
+        win.stop_curses()
+
+
+def test_legacy_instance_start_curses_reattaches_after_suspend():
+    # psistat's dump/return path calls self.window._start_curses() (the 1.4.x
+    # hook that was kept as a compatibility method).  It must leave the window
+    # usable, not create a screen and leave self.scr as None.
+    backend = HeadlessBackend()
+    win = _make(backend)
+    try:
+        win.add_body('kept across the dump')
+        win.suspend_curses()
+        assert win.scr is None and win.suspended
+
+        scr = win._start_curses()
+        assert scr is not None
+        assert win.scr is scr
+        assert win.suspended is False
+        assert win in ConsoleWindow.active_windows()
+        assert win.body.texts == ['kept across the dump']
+        win.clear()   # the call that crashed psistat after returning
+        assert scr.calls_named('clear')
+        win.add_body('after clear')
+    finally:
+        win.stop_curses()
+    assert win.scr is None
+
+
+def test_singleton_legacy_instance_start_curses_resumes_shared_screen():
+    # Same compatibility hook, but in the pre-2.0 singleton model, where
+    # stop_curses() suspends the shared screen rather than tearing it down.
+    code = '''
+from console_window.backend import HeadlessBackend
+from console_window.opts import ConsoleWindowOpts
+from console_window.window import ConsoleWindow
+
+backend = HeadlessBackend()
+win = ConsoleWindow(opts=ConsoleWindowOpts(body_rows=3, head_rows=2),
+                    backend=backend, singleton=True)
+win.add_body('kept across the dump')
+win.stop_curses()                 # pre-2.0 call: suspend
+assert win.scr is None and win.suspended
+
+scr = win._start_curses()         # psistat's "come back" call
+assert scr is not None
+assert win.scr is scr
+assert ConsoleWindow.static_scr is scr
+assert win.suspended is False
+assert win in ConsoleWindow.active_windows()
+assert win.body.texts == ['kept across the dump']
+win.clear()
+assert scr.calls_named('clear')
+win.add_body('after clear')
+
+ConsoleWindow.stop_all()          # permanent teardown
+assert win.scr is None and ConsoleWindow.static_scr is None
+'''
+    subprocess.run([sys.executable, '-c', code], check=True)
+
+
 def test_mixing_singleton_modes_asserts():
     code = '''
 from console_window.backend import HeadlessBackend