[REQUEST] Smoothing for speed and time_remaining in Progress Tasks

[liblaf]

First of all, thank you to the developers for creating and maintaining Rich! It's an incredibly powerful and visually appealing library that has made working with terminal applications a joy.

Feature Description

I'd like to propose adding smoothing functionality for the speed and time_remaining metrics in Rich's progress tasks. Currently, these values can appear jittery, especially when tasks involve variable workloads or uneven progress updates. Smoothing these metrics would make the progress bars look more polished and provide a better user experience.

Inspiration from Other Libraries

Other progress bar libraries, such as alive-progress and tqdm, already implement smoothing techniques to address this issue. For example:

alive-progress/alive_progress/utils/timing.py at 35853799b84ee682af121f7bc5967bd9b62e34c4 · rsalmei/alive-progress

def gen_simple_exponential_smoothing(alpha: float, fn: Callable[[float, float], float]):
    """Implements a generator with a simple exponential smoothing of some function.
    Given alpha and y_hat (t-1), we can calculate the next y_hat:
        y_hat = alpha * y + (1 - alpha) * y_hat
        y_hat = alpha * y + y_hat - alpha * y_hat
        y_hat = y_hat + alpha * (y - y_hat)


    Args:
        alpha: the smoothing coefficient
        fn: the function


    Returns:


    """
    p = (0.,)
    while any(x == 0. for x in p):
        p = yield 0.
    y_hat = fn(*p)
    while True:
        p = yield y_hat
        y = fn(*p)
        y_hat += alpha * (y - y_hat)

tqdm/tqdm/std.py at 0ed5d7f18fa3153834cbac0aa57e8092b217cc16 · tqdm/tqdm

class EMA(object):
    """
    Exponential moving average: smoothing to give progressively lower
    weights to older values.


    Parameters
    ----------
    smoothing  : float, optional
        Smoothing factor in range [0, 1], [default: 0.3].
        Increase to give more weight to recent values.
        Ranges from 0 (yields old value) to 1 (yields new value).
    """
    def __init__(self, smoothing=0.3):
        self.alpha = smoothing
        self.last = 0
        self.calls = 0


    def __call__(self, x=None):
        """
        Parameters
        ----------
        x  : float
            New value to include in EMA.
        """
        beta = 1 - self.alpha
        if x is not None:
            self.last = self.alpha * x + beta * self.last
            self.calls += 1
        return self.last / (1 - beta ** self.calls) if self.calls else self.last

Proposed Implementation

I suggest adding an optional smoothing parameter to the Progress class or Progress.add_task() method, which could be enabled and configured by the user. For example:

import time
from rich.progress import track

for i in track(range(20), description="Processing...", smoothing=0.3):
    time.sleep(1)  # Simulate work being done

Problem This Solves

The jittery behavior of speed and time_remaining can be distracting and make the progress bar feel less reliable. Smoothing these values would make the progress bar more useful for tasks with variable workloads, where raw values might fluctuate significantly.

Additional Considerations

• The smoothing algorithm should be optional and configurable (e.g., via a smoothing parameter).

Thank you for considering this feature! I'd be happy to provide more details or assist with implementation if needed.