refactor(bar): cooperative update/start/finish dispatch

Replace explicit class-qualified parent calls in the update/start/finish
chains with cooperative super() dispatch, mirroring the __init__ migration.

- ProgressBar._update_parents: three explicit parent update() calls (two of
  which resolved to the no-op ProgressBarMixinBase.update) collapse to a
  single super().update(value=value).
- ProgressBar.start / .finish: three explicit parent calls each collapse to
  one super() call.
- StdRedirectMixin/DefaultFdMixin/ResizableMixin internal explicit parent
  calls converted to super().

value is passed by keyword through the chain so the intermediate
`*args, **kwargs` and `value=None` signatures interoperate.

Ordering note: the SIGWINCH uninstall in ResizableMixin.finish now runs
before the stream unwrap in StdRedirectMixin.finish (previously after).
The two subsystems are independent, so behavior is unchanged.

Add two characterization tests: a super()-style update override is entered
exactly once per update() call (guards the collapsed chain against
re-dispatch), and finish(end='') threads end through the collapsed chain.

Author: wolph

progressbar/bar.py

@@ -339,7 +339,7 @@ def start(self, **kwargs: typing.Any):
         super().start()
 
     def update(self, *args: types.Any, **kwargs: types.Any) -> None:
-        ProgressBarMixinBase.update(self, *args, **kwargs)
+        super().update(*args, **kwargs)
 
         line: str = converters.to_unicode(self._format_line())
         if not self.enable_colors:
@@ -363,7 +363,7 @@ def finish(
             return
 
         end = kwargs.pop('end', '\n')
-        ProgressBarMixinBase.finish(self, *args, **kwargs)
+        super().finish(*args, **kwargs)
 
         if end and not self.line_breaks:
             self.fd.write(end)
@@ -500,7 +500,7 @@ def _handle_resize(
         self.term_width = w
 
     def finish(self):  # pragma: no cover
-        ProgressBarMixinBase.finish(self)
+        super().finish()
         if self.signal_set:
             with contextlib.suppress(Exception):
                 _ResizeRegistry.uninstall(self)
@@ -556,7 +556,7 @@ def start(self, *args: typing.Any, **kwargs: typing.Any):
         self.stderr = utils.streams.stderr
 
         utils.streams.start_capturing(self)
-        DefaultFdMixin.start(self, *args, **kwargs)
+        super().start(*args, **kwargs)
 
     def update(self, value: types.Optional[NumberT] = None):
         cleared = not self.line_breaks and utils.streams.needs_clear()
@@ -567,10 +567,10 @@ def update(self, value: types.Optional[NumberT] = None):
         if cleared and self.redirect_blank_line:
             # Keep a blank line between the redirected output and the bar
             self.fd.write('\n')
-        DefaultFdMixin.update(self, value=value)
+        super().update(value=value)
 
     def finish(self, end='\n'):
-        DefaultFdMixin.finish(self, end=end)
+        super().finish(end=end)
         utils.streams.stop_capturing(self)
         if self.redirect_stdout:
             utils.streams.unwrap_stdout()
@@ -1250,9 +1250,11 @@ def _update_variables(self, kwargs):
 
     def _update_parents(self, value: ValueT):
         self.updates += 1
-        ResizableMixin.update(self, value=value)
-        ProgressBarBase.update(self, value=value)
-        StdRedirectMixin.update(self, value=value)  # type: ignore
+        # Cooperative dispatch through the MRO
+        # (StdRedirectMixin -> DefaultFdMixin -> ProgressBarMixinBase). The
+        # `value` is passed by keyword so the intermediate `*args, **kwargs`
+        # and `value=None` signatures interoperate.
+        super().update(value=value)  # type: ignore
 
         # Only flush if something was actually written
         self.fd.flush()
@@ -1293,9 +1295,10 @@ def start(
         if self.max_value is None:
             self.max_value = self._DEFAULT_MAXVAL
 
-        StdRedirectMixin.start(self, max_value=max_value)
-        ResizableMixin.start(self, max_value=max_value)
-        ProgressBarBase.start(self, max_value=max_value)
+        # Cooperative dispatch through the MRO
+        # (StdRedirectMixin -> DefaultFdMixin -> ProgressBarMixinBase);
+        # ResizableMixin/ProgressBarBase define no `start` and are skipped.
+        super().start(max_value=max_value)
 
         # Constructing the default widgets is only done when we know max_value
         if not self.widgets:
@@ -1385,9 +1388,13 @@ def finish(self, end: str = '\n', dirty: bool = False):
             self.end_time = datetime.now()
             self.update(self.max_value, force=True)
 
-        StdRedirectMixin.finish(self, end=end)
-        ResizableMixin.finish(self)
-        ProgressBarBase.finish(self)
+        # Cooperative dispatch through the MRO
+        # (StdRedirectMixin -> DefaultFdMixin -> ResizableMixin ->
+        # ProgressBarMixinBase). Ordering note: the SIGWINCH uninstall in
+        # ResizableMixin.finish now runs *before* the stream unwrap in
+        # StdRedirectMixin.finish (previously it ran after). The two
+        # subsystems are independent, so the observable result is unchanged.
+        super().finish(end=end)
 
     @property
     def currval(self):

tests/test_subclass_compat.py

@@ -423,3 +423,72 @@ def test_old_style_triple_call_bar_consumes_one_index() -> None:
     # parent __init__ entry points reaching ProgressBarBase.
     assert first.index >= 0
     assert second.index == first.index + 1
+
+
+# --- update/start/finish chain: cooperative-super() guarantees --------------
+
+
+def test_super_style_update_override_dispatched_once() -> None:
+    """A super()-style ``update`` override runs exactly once per call.
+
+    The collapsed ``_update_parents`` chain dispatches to the *parent*
+    mixins via ``super().update(...)``, so it must never re-enter the
+    subclass's own ``update`` override. A double dispatch through the
+    chain would bump the counter twice.
+    """
+    calls = 0
+
+    class CountingBar(progressbar.ProgressBar):
+        def update(
+            self,
+            value: typing.Any = None,
+            force: bool = False,
+            **kwargs: typing.Any,
+        ) -> None:
+            nonlocal calls
+            calls += 1
+            super().update(value, force=force, **kwargs)
+
+    bar = CountingBar(fd=io.StringIO(), max_value=10, term_width=60)
+    # start() itself calls update(min_value); ignore those bootstrap calls.
+    bar.start()
+    calls = 0
+    bar.update(1, force=True)
+    assert calls == 1
+    bar.finish()
+
+
+def test_finish_end_kwarg_threads_through_chain() -> None:
+    """``finish(end='')`` still threads ``end`` through the collapsed chain.
+
+    ``end`` is popped inside ``DefaultFdMixin.finish`` after the migration;
+    an empty value must suppress the trailing newline while the default
+    still writes one.
+    """
+    fd_blank = io.StringIO()
+    bar = progressbar.ProgressBar(
+        fd=fd_blank,
+        max_value=10,
+        term_width=60,
+        enable_colors=False,
+        line_breaks=False,
+    )
+    bar.start()
+    bar.update(5, force=True)
+    bar.finish(end='')
+    assert bar.finished()
+    assert not fd_blank.getvalue().endswith('\n')
+
+    # Contrast: the default end='\n' still writes the trailing newline.
+    fd_newline = io.StringIO()
+    bar2 = progressbar.ProgressBar(
+        fd=fd_newline,
+        max_value=10,
+        term_width=60,
+        enable_colors=False,
+        line_breaks=False,
+    )
+    bar2.start()
+    bar2.update(5, force=True)
+    bar2.finish()
+    assert fd_newline.getvalue().endswith('\n')