refactor(widgets): dedup ETA value/elapsed + make UnknownLength explicit

ETA.__call__ and SmoothingETA.__call__ shared an identical value/elapsed
default-resolution preamble. Extract it into ETA._resolve_value_elapsed()
and call it from both; the shared helper's branches are covered by the ETA
paths so SmoothingETA no longer needs its two '# pragma: no branch'.

Also replace the TypeError-as-control-flow around _calculate_eta with an
explicit 'progress.max_value is base.UnknownLength' check. The only source
of that TypeError was subtracting the value from the UnknownLength sentinel
inside _calculate_eta's 'if elapsed:' branch, so the explicit check is
guarded by 'elapsed' too: this keeps the elapsed==0 case returning 0
(format_zero) instead of N/A, preserving byte-identical output. Nothing
else in the ETA math raises TypeError, so the try/except is removed
entirely rather than kept as a defensive handler.

Behavior-preserving: full suite + render goldens unchanged, widgets.py at
100% branch coverage.

Author: wolph

progressbar/widgets.py

@@ -569,33 +569,56 @@ def _calculate_eta(
         else:
             return 0
 
-    def __call__(
+    def _resolve_value_elapsed(
         self,
         progress: ProgressBarMixinBase,
         data: Data,
-        value=None,
-        elapsed=None,
+        value,
+        elapsed,
     ):
-        """Updates the widget to show the ETA or total time when finished."""
+        """Fill in the value/elapsed defaults shared by the ETA variants.
+
+        When a caller does not supply them, the per-item rate is based on the
+        progress relative to ``min_value`` (not the raw value) and the elapsed
+        time is taken from the data snapshot.
+        """
         if value is None:
-            # The per-item rate must be based on the progress relative to
-            # min_value, not the raw value
             value = data['value'] - progress.min_value
 
         if elapsed is None:
             elapsed = data['time_elapsed']
 
+        return value, elapsed
+
+    def __call__(
+        self,
+        progress: ProgressBarMixinBase,
+        data: Data,
+        value=None,
+        elapsed=None,
+    ):
+        """Updates the widget to show the ETA or total time when finished."""
+        value, elapsed = self._resolve_value_elapsed(
+            progress, data, value, elapsed
+        )
+
+        # ``max_value`` is ``UnknownLength`` for indeterminate bars. The
+        # remaining-count subtraction in ``_calculate_eta`` only runs (and
+        # only then fails) once ``elapsed`` is truthy, so guard on both to
+        # keep the ``elapsed == 0`` case rendering ``format_zero`` as before.
+        # Nothing else in the ETA math raises ``TypeError``, so the previous
+        # try/except-as-control-flow is intentionally removed.
         eta_na = False
-        try:
+        if elapsed and progress.max_value is base.UnknownLength:
+            data['eta_seconds'] = None
+            eta_na = True
+        else:
             data['eta_seconds'] = self._calculate_eta(
                 progress,
                 data,
                 value=value,
                 elapsed=elapsed,
             )
-        except TypeError:
-            data['eta_seconds'] = None
-            eta_na = True
 
         data['eta'] = None
         if data['eta_seconds']:
@@ -722,14 +745,9 @@ def __call__(
         value=None,
         elapsed=None,
     ):
-        if value is None:  # pragma: no branch
-            # The per-item rate must be based on the progress relative to
-            # min_value, not the raw value
-            value = data['value'] - progress.min_value
-
-        if elapsed is None:  # pragma: no branch
-            elapsed = data['time_elapsed']
-
+        value, elapsed = self._resolve_value_elapsed(
+            progress, data, value, elapsed
+        )
         value = self.smoothing_algorithm.update(value, elapsed)
         return ETA.__call__(self, progress, data, value=value, elapsed=elapsed)