Fix unknown-length redraw and animated marker fill at finish

- ProgressBar._needs_update now redraws unknown-length bars on every
  value change, so a non-time-sensitive widget set (e.g. the
  format_label example's FormatLabel) animates instead of jumping
  straight from the start value to the final value.
- AnimatedMarker keeps a filled bar full when finished instead of
  collapsing to a single marker character, fixing the
  filling_bar_animated_marker and color_bar_animated_marker_example
  examples emptying out at 100%.
- Isolate the SIGWINCH overlapping-bars regression test from global
  _ResizeRegistry state so the handler-restore branch is exercised
  deterministically regardless of suite ordering, restoring 100%
  coverage.

Adds targeted regression tests for each.

Author: wolph

progressbar/bar.py

@@ -946,6 +946,11 @@ def _needs_update(self):
         elif self.poll_interval and delta > self.poll_interval:
             # Needs to redraw timers and animations
             return True
+        elif self.max_value is base.UnknownLength:
+            # There's no terminal-width threshold to compute for an unknown
+            # length, so redraw whenever the value advanced (still rate
+            # limited by the min_poll_interval check above)
+            return self.value != self.previous_value
 
         # Update if value increment is not large enough to
         # add more bars to progressbar (according to current

progressbar/widgets.py

@@ -854,6 +854,11 @@ def __call__(self, progress: ProgressBarMixinBase, data: Data, width=None):
         finished.
         """
         if progress.end_time:
+            # When finished, keep a filling marker full instead of
+            # collapsing to a single character; a plain marker has no fill
+            # so it falls back to its default character.
+            if self.fill:
+                return self.fill(progress, data, width)
             return self.default
 
         marker = self.markers[data['updates'] % len(self.markers)]

tests/test_progressbar.py

@@ -159,23 +159,44 @@ def write(self, value: str) -> int:
 def test_sigwinch_restored_with_overlapping_bars() -> None:
     # Regression: A5 - with two live bars, finishing them in creation
     # order left a dangling handler installed.
-    original = signal.getsignal(signal.SIGWINCH)
+    from progressbar.bar import _ResizeRegistry
+
+    saved_handler = signal.getsignal(signal.SIGWINCH)
+    # Isolate the global registry so the assertions don't depend on bars
+    # left registered (and a handler left installed) by other tests
+    saved_bars = list(_ResizeRegistry.bars)
+    saved_prev = _ResizeRegistry.previous_handler
+    _ResizeRegistry.bars.clear()
+    _ResizeRegistry.previous_handler = None
+
+    # Start from a known sentinel handler so we can tell apart "still
+    # installed" from "restored" without depending on global state
+    signal.signal(signal.SIGWINCH, signal.SIG_IGN)
     try:
         bar1 = progressbar.ProgressBar(max_value=5, fd=io.StringIO())
         bar1.start()
         bar2 = progressbar.ProgressBar(max_value=5, fd=io.StringIO())
         bar2.start()
 
+        # The first bar installs the shared handler
+        assert signal.getsignal(signal.SIGWINCH) is not signal.SIG_IGN
+
         # A resize signal is dispatched to all live bars
         signal.raise_signal(signal.SIGWINCH)
         assert isinstance(bar1.term_width, int)
         assert isinstance(bar2.term_width, int)
 
         bar1.update(5)
         bar1.finish()
+        # The handler must stay installed while bar2 is still live
+        assert signal.getsignal(signal.SIGWINCH) is not signal.SIG_IGN
+
         bar2.update(5)
         bar2.finish()
-
-        assert signal.getsignal(signal.SIGWINCH) is original
+        # The last bar to finish restores the previous handler
+        assert signal.getsignal(signal.SIGWINCH) is signal.SIG_IGN
     finally:
-        signal.signal(signal.SIGWINCH, original)
+        for restored_bar in saved_bars:
+            _ResizeRegistry.bars.add(restored_bar)
+        _ResizeRegistry.previous_handler = saved_prev
+        signal.signal(signal.SIGWINCH, saved_handler)

tests/test_unknown_length.py

@@ -28,3 +28,23 @@ def test_unknown_length_at_start() -> None:
     for w in pb2.widgets:
         print(type(w), repr(w))
     assert any(isinstance(w, progressbar.Bar) for w in pb2.widgets)
+
+
+def test_unknown_length_redraws_on_value_change() -> None:
+    # With an unknown length and a non-time-sensitive widget (no
+    # `INTERVAL`), the bar still needs to redraw whenever the value
+    # advances; otherwise it would only ever show the start and finish
+    # values. See the `format_label` example.
+    pb = progressbar.ProgressBar(
+        widgets=[progressbar.FormatLabel('%(value)d')],
+        max_value=progressbar.UnknownLength,
+    ).start()
+
+    assert pb.poll_interval is None
+    pb.previous_value = 2
+    pb.value = 3
+    # Make sure the min_poll_interval rate limit is not what blocks us
+    pb._last_update_timer -= 10
+    assert pb._needs_update() is True
+
+    pb.finish()

tests/test_widgets.py

@@ -247,3 +247,26 @@ def test_bar_widget_respects_min_value() -> None:
     bar.start()
     assert '#' not in bar.fd.getvalue()
     bar.finish(dirty=True)
+
+
+def test_animated_marker_fill_stays_full_when_finished() -> None:
+    # Regression: a Bar filled by an AnimatedMarker(fill=...) collapsed to a
+    # single marker character at finish() because the end_time branch
+    # short-circuited before applying the fill. The finished bar must stay
+    # full instead of emptying out at 100%.
+    bar = progressbar.ProgressBar(
+        widgets=[progressbar.Bar(marker=progressbar.AnimatedMarker(fill='#'))],
+        max_value=10,
+        fd=io.StringIO(),
+        term_width=60,
+    )
+    bar.start()
+    for i in range(11):
+        bar.update(i)
+    bar.finish()
+
+    last_line = [
+        line for line in bar.fd.getvalue().split('\n') if line.strip()
+    ][-1]
+    # term_width 60 leaves ~58 fill characters; the collapse bug left ~1
+    assert last_line.count('#') > 40, repr(last_line)