Helper class for smooth values

yt_dlp/downloader/fragment.py

@@ -274,8 +274,8 @@ class FragmentFD(FileDownloader):
                 progress.thread_reset()
 
             state['downloaded_bytes'] = ctx['complete_frags_downloaded_bytes'] = progress.downloaded
-            ctx['speed'] = state['speed'] = progress.smooth_speed
-            state['eta'] = progress.eta
+            state['speed'] = ctx['speed'] = progress.speed.smooth
+            state['eta'] = progress.eta.smooth
 
             self._hook_progress(state, info_dict)
 

yt_dlp/utils/progress.py

@@ -6,21 +6,24 @@ import time
 
 
 class ProgressCalculator:
-    # Time to calculate the speed over (in nanoseconds)
-    SAMPLING_WINDOW = 1_000_000_000
-    # Factor for the exponential moving average (from 0 = prev to 1 = current)
-    SMOOTHING_FACTOR = 0.3
+    # Time to calculate the speed over (seconds)
+    SAMPLING_WINDOW = 3
+    # Minimum timeframe before to sample next downloaded bytes (seconds)
+    SAMPLING_RATE = 0.05
+    # Time before showing eta (seconds)
+    GRACE_PERIOD = 1
 
     def __init__(self, initial: int):
-        self.downloaded = initial or 0
+        self._initial = initial or 0
+        self.downloaded = self._initial
 
         self.elapsed: float = 0
-        self.speed: float = 0
-        self.smooth_speed: int = 0
-        self.eta: float | None = None
+        self.speed = SmoothValue(0, smoothing=0.7)
+        self.eta = SmoothValue(None, smoothing=0.9)
 
-        self._total = None
-        self._start_time = time.monotonic_ns()
+        self._total = 0
+        self._start_time = time.monotonic()
+        self._last_update = self._start_time
 
         self._lock = threading.Lock()
         self._thread_sizes: dict[int, int] = {}
@@ -35,9 +38,7 @@ class ProgressCalculator:
     @total.setter
     def total(self, value: int | None):
         with self._lock:
-            if not value:
-                value = None
-            elif value < self.downloaded:
+            if value is not None and value < self.downloaded:
                 value = self.downloaded
 
             self._total = value
@@ -59,29 +60,50 @@ class ProgressCalculator:
             self._update(size - last_size)
 
     def _update(self, size: int):
-        current_time = time.monotonic_ns()
+        current_time = time.monotonic()
 
         self.downloaded += size
-        self.elapsed = (current_time - self._start_time) / 1_000_000_000
+        self.elapsed = current_time - self._start_time
         if self.total is not None and self.downloaded > self.total:
             self._total = self.downloaded
 
+        if self._last_update + self.SAMPLING_RATE > current_time:
+            return
+        self._last_update = current_time
+
         self._times.append(current_time)
         self._downloaded.append(self.downloaded)
 
         offset = bisect.bisect_left(self._times, current_time - self.SAMPLING_WINDOW)
         del self._times[:offset]
         del self._downloaded[:offset]
+        if len(self._times) < 2:
+            self.speed.reset()
+            self.eta.reset()
+            return
 
         download_time = current_time - self._times[0]
         if not download_time:
             return
-        downloaded_bytes = self.downloaded - self._downloaded[0]
 
-        self.speed = downloaded_bytes * 1_000_000_000 / download_time
-        self.smooth_speed = int(self.SMOOTHING_FACTOR * self.speed + (1 - self.SMOOTHING_FACTOR) * self.smooth_speed)
+        self.speed.set((self.downloaded - self._downloaded[0]) / download_time)
+        if self.total and self.speed.value and self.elapsed > self.GRACE_PERIOD:
+            self.eta.set((self.total - self.downloaded) / self.speed.value)
+        else:
+            self.eta.reset()
 
-        if not self.total:
-            self.eta = None
-        elif self.speed:
-            self.eta = (self.total - self.downloaded) / self.speed
+
+class SmoothValue:
+    def __init__(self, initial: float | None, smoothing: float):
+        self.value = self.smooth = self._initial = initial
+        self._smoothing = smoothing
+
+    def set(self, value: float):
+        self.value = value
+        if self.smooth is None:
+            self.smooth = self.value
+        else:
+            self.smooth = (1 - self._smoothing) * value + self._smoothing * self.smooth
+
+    def reset(self):
+        self.value = self.smooth = self._initial