asyncprogress 0.3.4__tar.gz → 0.3.5__tar.gz

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asyncprogress
-Version: 0.3.4
+Version: 0.3.5
 Summary: Async-aware progress bars for Python's asyncio ecosystem. Zero mandatory dependencies.
 License: MIT
 License-File: LICENSE
@@ -19,9 +19,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
 Provides-Extra: color
 Requires-Dist: colorama (>=0.4.4) ; extra == "color"
+Project-URL: Homepage, https://github.com/agentsoft/asyncprogress
+Project-URL: Repository, https://github.com/agentsoft/asyncprogress
 Description-Content-Type: text/markdown
 
 # asyncprogress
@@ -34,13 +36,14 @@ Async-aware progress bars for Python's asyncio ecosystem. Zero mandatory depende
 
 ## Why asyncprogress?
 
-Existing progress bar libraries (`tqdm`, `rich`, `alive-progress`) were built for synchronous
-code. `asyncprogress` is designed from the ground up for `asyncio`:
+Existing progress bar libraries (`tqdm`, `rich`, `alive-progress`) were designed for
+synchronous code. `asyncprogress` is built from the ground up for `asyncio`:
 
-- **Native `async for` support** — wrap any sync or async iterable
+- **Native `async for` support** — wrap any sync or async iterable with one line
 - **Accurate ETA** — EWMA-based estimation handles bursty async I/O patterns
 - **Concurrent task tracking** — `gather()` and `aprogress_as_completed()` for task pools
 - **Spinner mode** — automatic fallback for unknown-length streams
+- **Multiple concurrent bars** — `MultiProgressBar` for parallel pipelines
 - **Zero mandatory dependencies** — pure Python stdlib (`asyncio`, `sys`, `time`)
 
 ## Installation

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/README.md

@@ -8,13 +8,14 @@ Async-aware progress bars for Python's asyncio ecosystem. Zero mandatory depende
 
 ## Why asyncprogress?
 
-Existing progress bar libraries (`tqdm`, `rich`, `alive-progress`) were built for synchronous
-code. `asyncprogress` is designed from the ground up for `asyncio`:
+Existing progress bar libraries (`tqdm`, `rich`, `alive-progress`) were designed for
+synchronous code. `asyncprogress` is built from the ground up for `asyncio`:
 
-- **Native `async for` support** — wrap any sync or async iterable
+- **Native `async for` support** — wrap any sync or async iterable with one line
 - **Accurate ETA** — EWMA-based estimation handles bursty async I/O patterns
 - **Concurrent task tracking** — `gather()` and `aprogress_as_completed()` for task pools
 - **Spinner mode** — automatic fallback for unknown-length streams
+- **Multiple concurrent bars** — `MultiProgressBar` for parallel pipelines
 - **Zero mandatory dependencies** — pure Python stdlib (`asyncio`, `sys`, `time`)
 
 ## Installation

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/pyproject.toml

@@ -1,11 +1,12 @@
 [tool.poetry]
 name = "asyncprogress"
-version = "0.3.4"
+version = "0.3.5"
 description = "Async-aware progress bars for Python's asyncio ecosystem. Zero mandatory dependencies."
 authors = ["AgentSoft <agentsoft@example.com>"]
 readme = "README.md"
 license = "MIT"
-packages = [{include = "asyncprogress", from = "src"}]
+homepage = "https://github.com/agentsoft/asyncprogress"
+repository = "https://github.com/agentsoft/asyncprogress"
 keywords = ["asyncio", "progress", "progress-bar", "async", "tqdm"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -16,9 +17,10 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
     "Framework :: AsyncIO",
 ]
+packages = [{include = "asyncprogress", from = "src"}]
 
 [tool.poetry.dependencies]
 python = "^3.9"
@@ -47,7 +49,7 @@ line-length = 100
 target-version = "py39"
 
 [tool.ruff.lint]
-select = ["E", "F", "W", "I", "UP"]
+select = ["E", "F", "I", "UP"]
 ignore = ["E501"]
 
 [tool.coverage.run]

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/src/asyncprogress/__init__.py

@@ -22,4 +22,4 @@ __all__ = [
     "aprogress_as_completed",
 ]
 
-__version__ = "0.3.4"
+__version__ = "0.3.5"

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/src/asyncprogress/_bar.py

@@ -12,7 +12,7 @@ from typing import Any, TextIO, TypeVar
 
 from asyncprogress._eta import EWMACalculator
 from asyncprogress._renderer import BarRenderer
-from asyncprogress._terminal import erase_line, is_tty, move_cursor_up
+from asyncprogress._terminal import erase_line, is_tty
 
 T = TypeVar("T")
 
@@ -21,11 +21,8 @@ class ProgressBar:
     """
     Async context manager for manual progress tracking.
 
-    Usage:
-        async with ProgressBar(total=100, description="Processing") as bar:
-            for item in items:
-                await process(item)
-                await bar.update()
+    Provides a progress bar with EWMA-based ETA estimation, configurable
+    appearance, and non-blocking terminal output.
 
     Args:
         total: Total number of steps. None activates spinner mode.
@@ -34,17 +31,23 @@ class ProgressBar:
         fill_char: Character for completed portion.
         empty_char: Character for remaining portion.
         color: ANSI color name (e.g., "green", "cyan", "red").
-        show_eta: Show estimated time remaining.
-        show_elapsed: Show elapsed time.
-        show_count: Show [completed/total] count.
-        show_percentage: Show percentage.
+        show_eta: Whether to show estimated time remaining.
+        show_elapsed: Whether to show elapsed time.
+        show_count: Whether to show [completed/total] count.
+        show_percentage: Whether to show percentage.
         update_interval: Seconds between terminal redraws.
-        ewma_alpha: EWMA smoothing factor (0 < alpha <= 1).
+        ewma_alpha: EWMA smoothing factor (0.1=smooth, 0.5=reactive).
         file: Output stream (default: sys.stderr).
-        disable: Suppress all output if True.
-        unit: Unit label (e.g., "it", "B").
-        unit_scale: Auto-scale with SI prefix (K/M/G).
+        disable: If True, suppress all output.
+        unit: Unit label ("it" for items, "B" for bytes, etc.).
+        unit_scale: If True, auto-apply SI prefix (K/M/G).
         unit_divisor: 1000 for SI, 1024 for binary.
+
+    Example:
+        async with ProgressBar(total=100, description="Processing") as bar:
+            for item in items:
+                await process(item)
+                await bar.update()
     """
 
     def __init__(
@@ -90,22 +93,16 @@ class ProgressBar:
         self._last_render_time: float = 0.0
         self._spinner_frame: int = 0
         self._render_task: asyncio.Task[None] | None = None
+        self._running: bool = False
 
         self._eta_calc = EWMACalculator(alpha=ewma_alpha)
         self._renderer = BarRenderer()
 
-        # Track whether we've written any output (for cursor control)
-        self._lines_written: int = 0
-
     async def __aenter__(self) -> ProgressBar:
         """Start the progress bar."""
         self._start_time = time.monotonic()
-        self._last_render_time = 0.0
-        self._finished = False
-        self._completed = 0
-        self._spinner_frame = 0
-        self._eta_calc.reset()
-        # Start background render loop
+        self._last_render_time = self._start_time
+        self._running = True
         self._render_task = asyncio.create_task(self._render_loop())
         await asyncio.sleep(0)  # Yield so render task can initialize
         return self
@@ -113,7 +110,8 @@ class ProgressBar:
     async def __aexit__(self, *args: Any) -> None:
         """Stop the progress bar and render final state."""
         await self.finish()
-        if self._render_task is not None and not self._render_task.done():
+        self._running = False
+        if self._render_task is not None:
             self._render_task.cancel()
             try:
                 await self._render_task
@@ -122,13 +120,11 @@ class ProgressBar:
             self._render_task = None
 
     async def _render_loop(self) -> None:
-        """Background task that periodically redraws the bar."""
-        while not self._finished:
-            now = time.monotonic()
-            if now - self._last_render_time >= self._update_interval:
-                self._write_line(self._get_render_string())
-                self._last_render_time = now
+        """Background task that periodically re-renders the bar."""
+        while self._running:
             await asyncio.sleep(self._update_interval)
+            if self._running and not self._finished:
+                self._write_line(self._get_render_string())
 
     def _get_render_string(self) -> str:
         """Build the current render string (spinner or bar)."""
@@ -143,6 +139,9 @@ class ProgressBar:
                 color=self._color,
                 show_elapsed=self._show_elapsed,
                 show_count=self._show_count,
+                unit=self._unit,
+                unit_scale=self._unit_scale,
+                unit_divisor=self._unit_divisor,
             )
         return self._renderer.render(
             description=self._description,
@@ -164,36 +163,39 @@ class ProgressBar:
             unit_divisor=self._unit_divisor,
         )
 
-    def _write_line(self, line: str) -> None:
+    def _write_line(self, text: str) -> None:
         """Write a progress line to the output file."""
         if self._disable:
             return
-        tty = is_tty(self._file)
-        if tty and self._lines_written > 0:
-            # Erase previous line on TTY
-            self._file.write(move_cursor_up(1) + erase_line())
-        self._file.write(line + "\n")
+        if is_tty(self._file):
+            self._file.write(erase_line() + text)
+        else:
+            self._file.write("\r" + text)
         self._file.flush()
-        self._lines_written = 1
 
     async def _render_final(self) -> None:
-        """Render the final (completed) state of the bar."""
+        """Render the final completed state."""
         if self._disable:
             return
-        self._write_line(self._get_render_string())
+        line = self._get_render_string()
+        if is_tty(self._file):
+            self._file.write(erase_line() + line + "\n")
+        else:
+            self._file.write("\r" + line + "\n")
+        self._file.flush()
 
     async def _schedule_render(self) -> None:
-        """Schedule a render if enough time has passed."""
+        """Trigger an immediate render if enough time has passed."""
         now = time.monotonic()
         if now - self._last_render_time >= self._update_interval:
-            self._write_line(self._get_render_string())
             self._last_render_time = now
+            self._write_line(self._get_render_string())
 
     async def update(self, n: int = 1) -> None:
         """
         Increment progress by n steps.
 
-        No-op if the bar is already finished.
+        No-op if the bar has already been finished.
         Clamps to total if total is set.
         """
         if self._finished:
@@ -208,7 +210,7 @@ class ProgressBar:
         """
         Set absolute progress to value, clamped to [0, total].
 
-        No-op if the bar is already finished.
+        No-op if the bar has already been finished.
         """
         if self._finished:
             return
@@ -237,23 +239,6 @@ class ProgressBar:
             self._completed = self._total
         await self._render_final()
 
-    # ── Read-only properties ──────────────────────────────────────────────────
-
-    @property
-    def description(self) -> str:
-        """The current description label for this progress bar."""
-        return self._description
-
-    @property
-    def completed(self) -> int:
-        """Number of steps completed so far."""
-        return self._completed
-
-    @property
-    def total(self) -> int | None:
-        """Total steps, or None if indeterminate."""
-        return self._total
-
     @property
     def elapsed(self) -> float:
         """Seconds since bar was started."""
@@ -274,7 +259,20 @@ class ProgressBar:
         """Current EWMA-smoothed items/second rate."""
         return self._eta_calc.rate()
 
-    # ── Convenience classmethod ───────────────────────────────────────────────
+    @property
+    def description(self) -> str:
+        """The current description label for this progress bar."""
+        return self._description
+
+    @property
+    def completed(self) -> int:
+        """Number of steps completed so far."""
+        return self._completed
+
+    @property
+    def total(self) -> int | None:
+        """Total steps, or None if indeterminate."""
+        return self._total
 
     @classmethod
     def track(
@@ -295,7 +293,7 @@ class ProgressBar:
             iterable: Any sync or async iterable.
             total: Total item count. Inferred from __len__ if available.
             description: Label shown on the progress bar.
-            **kwargs: Forwarded to ProgressBar (color, bar_width, show_eta, etc.)
+            **kwargs: Forwarded to ProgressBar constructor.
 
         Yields:
             Items from the iterable, in order.

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/src/asyncprogress/_eta.py

@@ -1,7 +1,7 @@
 """
 EWMA-based ETA calculator for asyncprogress.
 
-Pure math module — no I/O, fully unit-testable.
+Pure math — no I/O, fully unit-testable.
 """
 
 from __future__ import annotations
@@ -15,46 +15,42 @@ class EWMACalculator:
     which better handles the bursty completion patterns common in async I/O.
 
     Args:
-        alpha: Smoothing factor. Higher = more weight on recent samples.
+        alpha: Smoothing factor (0 < alpha <= 1).
+               Higher values give more weight to recent samples.
                Recommended range: 0.1 (smooth) to 0.5 (reactive).
     """
 
     def __init__(self, alpha: float = 0.3) -> None:
-        if not (0 < alpha <= 1.0):
+        if not (0 < alpha <= 1):
             raise ValueError(f"alpha must be in (0, 1], got {alpha}")
         self._alpha = alpha
         self._ewma_rate: float | None = None
         self._last_timestamp: float | None = None
-        self._last_completed: int = 0
+        self._last_completed: int | None = None
 
     def record(self, timestamp: float, completed: int) -> None:
         """Record a completion event at the given timestamp."""
-        if self._last_timestamp is None:
-            self._last_timestamp = timestamp
-            self._last_completed = completed
-            return
-
-        dt = timestamp - self._last_timestamp
-        dc = completed - self._last_completed
-
-        if dt > 0:
-            instant_rate = dc / dt
-            if self._ewma_rate is None:
-                self._ewma_rate = instant_rate
-            else:
-                self._ewma_rate = (
-                    self._alpha * instant_rate + (1 - self._alpha) * self._ewma_rate
-                )
-
+        if self._last_timestamp is not None and self._last_completed is not None:
+            dt = timestamp - self._last_timestamp
+            dc = completed - self._last_completed
+            if dt > 0:
+                instant_rate = dc / dt
+                if self._ewma_rate is None:
+                    self._ewma_rate = instant_rate
+                else:
+                    self._ewma_rate = (
+                        self._alpha * instant_rate + (1 - self._alpha) * self._ewma_rate
+                    )
+            # If dt == 0, we skip updating the rate (same timestamp)
         self._last_timestamp = timestamp
         self._last_completed = completed
 
     def rate(self) -> float | None:
-        """Returns smoothed items/second, or None if insufficient data."""
+        """Return smoothed items/second, or None if insufficient data."""
         return self._ewma_rate
 
     def eta(self, remaining: int) -> float | None:
-        """Returns estimated seconds to completion, or None if unknown."""
+        """Return estimated seconds to completion, or None if unknown."""
         if remaining == 0:
             return 0.0
         r = self.rate()
@@ -66,4 +62,4 @@ class EWMACalculator:
         """Reset all state."""
         self._ewma_rate = None
         self._last_timestamp = None
-        self._last_completed = 0
+        self._last_completed = None

asyncprogress-0.3.5/src/asyncprogress/_gather.py

@@ -0,0 +1,72 @@
+"""gather() — drop-in replacement for asyncio.gather() with progress tracking."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Coroutine
+from typing import Any
+
+from asyncprogress._bar import ProgressBar
+
+
+async def gather(
+    *coros_or_tasks: Coroutine[Any, Any, Any] | asyncio.Task[Any],
+    description: str = "",
+    return_exceptions: bool = False,
+    **progress_kwargs: Any,
+) -> list[Any]:
+    """
+    Drop-in replacement for asyncio.gather() with progress tracking.
+
+    Returns results in the same order as inputs.
+
+    Args:
+        *coros_or_tasks: Coroutines or Tasks to run concurrently.
+        description: Label shown on the progress bar.
+        return_exceptions: If True, exceptions are returned as values.
+        **progress_kwargs: Forwarded to ProgressBar (color, bar_width, etc.)
+
+    Returns:
+        List of results in submission order.
+
+    Example:
+        results = await gather(
+            *[fetch(url) for url in urls],
+            description="Fetching",
+            color="cyan",
+        )
+    """
+    if not coros_or_tasks:
+        return []
+
+    total = len(coros_or_tasks)
+
+    async with ProgressBar(
+        total=total, description=description, **progress_kwargs
+    ) as bar:
+        # Wrap each coroutine/task to update the bar on completion
+        results: list[Any] = [None] * total
+        exceptions: list[BaseException | None] = [None] * total
+
+        async def _run_one(idx: int, coro: Any) -> None:
+            try:
+                results[idx] = await coro
+            except Exception as exc:  # noqa: BLE001
+                exceptions[idx] = exc
+            finally:
+                await bar.update()
+
+        tasks = [asyncio.create_task(_run_one(i, c)) for i, c in enumerate(coros_or_tasks)]
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+    # Re-raise or return exceptions based on return_exceptions flag
+    final: list[Any] = []
+    for i in range(total):
+        if exceptions[i] is not None:
+            if return_exceptions:
+                final.append(exceptions[i])
+            else:
+                raise exceptions[i]  # type: ignore[misc]
+        else:
+            final.append(results[i])
+    return final

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/src/asyncprogress/_iterator.py

@@ -1,5 +1,5 @@
 """
-aprogress() — async generator wrapper for progress tracking.
+aprogress() — async generator wrapper for iterables.
 """
 
 from __future__ import annotations
@@ -32,13 +32,12 @@ async def aprogress(
     unit: str = "it",
     unit_scale: bool = False,
     unit_divisor: int = 1000,
-    **kwargs: Any,
 ) -> AsyncGenerator[T, None]:
     """
     Async generator wrapper that displays a progress bar while iterating.
 
-    Accepts both sync and async iterables. Automatically infers total from
-    __len__ when available. Falls back to spinner mode when total is unknown.
+    Automatically infers total from __len__ if available. Falls back to
+    spinner mode when total is unknown.
 
     Args:
         iterable: Any sync or async iterable.
@@ -48,35 +47,35 @@ async def aprogress(
         fill_char: Character for completed portion.
         empty_char: Character for remaining portion.
         color: ANSI color name (e.g., "green", "cyan").
-        show_eta: Show estimated time remaining.
-        show_elapsed: Show elapsed time.
-        show_count: Show count display.
-        show_percentage: Show percentage.
+        show_eta: Whether to show estimated time remaining.
+        show_elapsed: Whether to show elapsed time.
+        show_count: Whether to show [completed/total] count.
+        show_percentage: Whether to show percentage.
         update_interval: Seconds between terminal redraws.
         ewma_alpha: EWMA smoothing factor.
         file: Output stream (default: sys.stderr).
-        disable: Suppress all output if True.
-        unit: Unit label (e.g., "it", "B").
-        unit_scale: Auto-scale with SI prefix.
+        disable: If True, suppress all output.
+        unit: Unit label ("it" for items, "B" for bytes, etc.).
+        unit_scale: If True, auto-apply SI prefix (K/M/G).
         unit_divisor: 1000 for SI, 1024 for binary.
 
     Yields:
         Items from the iterable, in order.
 
     Example:
-        async for item in aprogress(my_list, description="Processing"):
+        async for item in aprogress(range(100), description="Processing"):
             await process(item)
     """
     import sys as _sys
 
-    # Infer total from __len__ if not provided
+    # Infer total from __len__ if available
     if total is None and hasattr(iterable, "__len__"):
         total = len(iterable)  # type: ignore[arg-type]
 
-    effective_total = total if total is not None else 0
+    effective_total = total if total is not None else None
 
-    bar_kwargs: dict[str, Any] = {
-        "total": effective_total if total is not None else None,
+    kwargs: dict[str, Any] = {
+        "total": effective_total,
         "description": description,
         "bar_width": bar_width,
         "fill_char": fill_char,
@@ -88,16 +87,17 @@ async def aprogress(
         "show_percentage": show_percentage,
         "update_interval": update_interval,
         "ewma_alpha": ewma_alpha,
-        "file": file if file is not None else _sys.stderr,
         "disable": disable,
         "unit": unit,
         "unit_scale": unit_scale,
         "unit_divisor": unit_divisor,
     }
-    # Merge any extra kwargs
-    bar_kwargs.update(kwargs)
+    if file is not None:
+        kwargs["file"] = file
+    else:
+        kwargs["file"] = _sys.stderr
 
-    async with ProgressBar(**bar_kwargs) as bar:
+    async with ProgressBar(**kwargs) as bar:
         count = 0
         if hasattr(iterable, "__aiter__"):
             async for item in iterable:  # type: ignore[union-attr]

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/src/asyncprogress/_renderer.py

@@ -8,40 +8,32 @@ from __future__ import annotations
 
 SPINNER_FRAMES: list[str] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
 
-_ANSI_COLORS: dict[str, str] = {
-    "black": "\x1b[30m",
-    "red": "\x1b[31m",
-    "green": "\x1b[32m",
-    "yellow": "\x1b[33m",
-    "blue": "\x1b[34m",
-    "magenta": "\x1b[35m",
-    "cyan": "\x1b[36m",
-    "white": "\x1b[37m",
-    "bright_black": "\x1b[90m",
-    "bright_red": "\x1b[91m",
-    "bright_green": "\x1b[92m",
-    "bright_yellow": "\x1b[93m",
-    "bright_blue": "\x1b[94m",
-    "bright_magenta": "\x1b[95m",
-    "bright_cyan": "\x1b[96m",
-    "bright_white": "\x1b[97m",
+ANSI_COLORS: dict[str, str] = {
+    "black": "\033[30m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "white": "\033[37m",
+    "bright_black": "\033[90m",
+    "bright_red": "\033[91m",
+    "bright_green": "\033[92m",
+    "bright_yellow": "\033[93m",
+    "bright_blue": "\033[94m",
+    "bright_magenta": "\033[95m",
+    "bright_cyan": "\033[96m",
+    "bright_white": "\033[97m",
 }
-_ANSI_RESET = "\x1b[0m"
+ANSI_RESET = "\033[0m"
 
 _SI_PREFIXES = ["", "K", "M", "G", "T", "P"]
 _BINARY_PREFIXES = ["", "Ki", "Mi", "Gi", "Ti", "Pi"]
 
 
-def _apply_color(text: str, color: str) -> str:
-    """Apply ANSI color to text, returning the colored string."""
-    code = _ANSI_COLORS.get(color.lower(), "")
-    if not code:
-        return text
-    return f"{code}{text}{_ANSI_RESET}"
-
-
 def _format_duration(seconds: float) -> str:
-    """Format a duration in seconds as H:MM:SS or M:SS."""
+    """Format seconds as H:MM:SS or M:SS."""
     m, s = divmod(int(seconds), 60)
     h, m = divmod(m, 60)
     if h:
@@ -49,6 +41,14 @@ def _format_duration(seconds: float) -> str:
     return f"{m}:{s:02d}"
 
 
+def _apply_color(text: str, color: str) -> str:
+    """Apply ANSI color to text."""
+    code = ANSI_COLORS.get(color.lower(), "")
+    if not code:
+        return text
+    return f"{code}{text}{ANSI_RESET}"
+
+
 def _scale_value(value: float, divisor: int) -> tuple[float, str]:
     """Return (scaled_value, prefix_string) for display."""
     prefixes = _BINARY_PREFIXES if divisor == 1024 else _SI_PREFIXES
@@ -61,13 +61,13 @@ def _scale_value(value: float, divisor: int) -> tuple[float, str]:
 
 class BarRenderer:
     """
-    Renders progress bar strings for terminal output.
+    Renders a single-line progress bar string.
 
-    String formatting only — no I/O side effects.
+    No I/O — returns strings only. Fully unit-testable.
     """
 
     def _compute_percentage(self, completed: int, total: int) -> float:
-        """Compute percentage, handling zero total gracefully."""
+        """Compute percentage, handling total=0 gracefully."""
         if total == 0:
             return 100.0  # Empty collection is trivially complete
         return min(100.0, (completed / total) * 100.0)
@@ -128,53 +128,45 @@ class BarRenderer:
         unit_divisor: int = 1000,
     ) -> str:
         """
-        Render a single-line progress bar string.
+        Render a single-line deterministic progress bar string.
 
         Returns a string ready for terminal output (no newline).
         """
         parts: list[str] = []
 
-        # Description
         if description:
             parts.append(description)
 
-        # Bar graphic
         if total is not None:
             pct = self._compute_percentage(completed, total)
             filled = int(bar_width * pct / 100)
             bar = fill_char * filled + empty_char * (bar_width - filled)
             parts.append(f" {bar} ")
 
-            # Percentage
             if show_percentage:
                 parts.append(f"{pct:.0f}%")
 
-            # Count
             if show_count:
                 parts.append(
                     self._format_count(completed, total, unit, unit_scale, unit_divisor)
                 )
         else:
-            # No total — just show count
             if show_count:
                 parts.append(
                     self._format_count(completed, None, unit, unit_scale, unit_divisor)
                 )
 
-        # Elapsed
         if show_elapsed:
             parts.append(f"⏱ {_format_duration(elapsed)}")
 
-        # Rate
+        if show_eta and eta is not None:
+            parts.append(f"ETA: {_format_duration(eta)}")
+
         rate_str = self._format_rate(rate, unit, unit_scale, unit_divisor)
         if rate_str:
             parts.append(rate_str)
 
-        # ETA
-        if show_eta and eta is not None:
-            parts.append(f"ETA: {_format_duration(eta)}")
-
-        line = "  ".join(parts)
+        line = " ".join(parts)
         if color:
             line = _apply_color(line, color)
         return line
@@ -190,19 +182,34 @@ class BarRenderer:
         color: str | None,
         show_elapsed: bool = True,
         show_count: bool = True,
+        unit: str = "it",
+        unit_scale: bool = False,
+        unit_divisor: int = 1000,
     ) -> str:
-        """Render a single-line spinner for indeterminate progress."""
+        """
+        Render a single-line spinner for indeterminate progress.
+
+        Activates automatically when total is None.
+        """
         spinner = SPINNER_FRAMES[frame_index % len(SPINNER_FRAMES)]
         parts: list[str] = []
         if description:
             parts.append(description)
         parts.append(spinner)
         if show_count:
-            parts.append(f"{completed} items")
+            if unit == "it":
+                parts.append(f"{completed} items")
+            else:
+                count_str = self._format_count(
+                    completed, None, unit, unit_scale, unit_divisor
+                )
+                parts.append(count_str)
         if show_elapsed:
             parts.append(f"⏱ {_format_duration(elapsed)}")
         if rate is not None:
-            parts.append(f"{rate:.1f} items/s")
+            rate_str = self._format_rate(rate, unit, unit_scale, unit_divisor)
+            if rate_str:
+                parts.append(rate_str)
         line = "  ".join(parts)
         if color:
             line = _apply_color(line, color)

{asyncprogress-0.3.4 → asyncprogress-0.3.5}/src/asyncprogress/_terminal.py

@@ -1,5 +1,5 @@
 """
-Terminal utilities: TTY detection, ANSI escape sequences, cursor control.
+Terminal utilities: TTY detection, ANSI cursor control.
 """
 
 from __future__ import annotations
@@ -15,19 +15,19 @@ def is_tty(file: TextIO = sys.stderr) -> bool:
 
 def move_cursor_up(n: int = 1) -> str:
     """Return ANSI escape sequence to move cursor up n lines."""
-    return f"\x1b[{n}A"
+    return f"\033[{n}A"
 
 
 def erase_line() -> str:
     """Return ANSI escape sequence to erase the current line."""
-    return "\x1b[2K\r"
+    return "\033[2K\r"
 
 
 def hide_cursor() -> str:
     """Return ANSI escape sequence to hide the cursor."""
-    return "\x1b[?25l"
+    return "\033[?25l"
 
 
 def show_cursor() -> str:
     """Return ANSI escape sequence to show the cursor."""
-    return "\x1b[?25h"
+    return "\033[?25h"

asyncprogress-0.3.4/src/asyncprogress/_gather.py

@@ -1,111 +0,0 @@
-"""
-gather() — Drop-in replacement for asyncio.gather() with progress tracking.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Coroutine
-from typing import Any
-
-from asyncprogress._bar import ProgressBar
-
-
-async def gather(
-    *coros_or_tasks: Coroutine[Any, Any, Any] | asyncio.Task[Any],
-    description: str = "",
-    return_exceptions: bool = False,
-    **progress_kwargs: Any,
-) -> list[Any]:
-    """
-    Drop-in replacement for asyncio.gather() with progress tracking.
-
-    Returns results in the same order as inputs.
-
-    Args:
-        *coros_or_tasks: Coroutines or tasks to run concurrently.
-        description: Label shown on the progress bar.
-        return_exceptions: If True, exceptions are returned as values
-                           rather than raised (mirrors asyncio.gather behavior).
-        **progress_kwargs: Forwarded to ProgressBar (color, bar_width, etc.)
-
-    Returns:
-        List of results in submission order.
-
-    Example:
-        results = await gather(
-            *[fetch(url) for url in urls],
-            description="Fetching",
-            color="cyan",
-        )
-    """
-    if not coros_or_tasks:
-        return []
-
-    total = len(coros_or_tasks)
-
-    async with ProgressBar(
-        total=total, description=description, **progress_kwargs
-    ) as bar:
-        # Convert all coroutines to tasks
-        tasks: list[asyncio.Task[Any]] = []
-        for item in coros_or_tasks:
-            if isinstance(item, asyncio.Task):
-                tasks.append(item)
-            else:
-                tasks.append(asyncio.create_task(item))
-
-        # Track results in order
-        results: list[Any] = [None] * total
-        pending = set(tasks)
-        task_index = {task: i for i, task in enumerate(tasks)}
-
-        # Add completion callbacks
-        completed_count = 0
-
-        async def wait_for_all() -> None:
-            nonlocal completed_count
-            for future in asyncio.as_completed(list(pending)):
-                try:
-                    result = await future
-                    # Find original index — we need to track by task identity
-                    completed_count += 1
-                    await bar.update()
-                    _ = result  # will be collected below
-                except Exception:
-                    completed_count += 1
-                    await bar.update()
-                    if not return_exceptions:
-                        raise
-
-        # Actually gather with proper ordering
-        # Use asyncio.gather for ordering, but track progress via callbacks
-        # Reset bar since we already incremented via wait_for_all approach
-        # Better approach: use done callbacks
-
-    # Re-implement with proper ordering using gather + callbacks
-    async with ProgressBar(
-        total=total, description=description, **progress_kwargs
-    ) as bar:
-        tasks2: list[asyncio.Task[Any]] = []
-        for item in coros_or_tasks:
-            if isinstance(item, asyncio.Task):
-                tasks2.append(item)
-            else:
-                tasks2.append(asyncio.create_task(item))
-
-        # Wrap each task to update bar on completion
-        async def tracked(task: asyncio.Task[Any]) -> Any:
-            try:
-                result = await task
-                await bar.update()
-                return result
-            except Exception as exc:
-                await bar.update()
-                raise exc
-
-        tracked_tasks = [tracked(t) for t in tasks2]
-        raw_results = await asyncio.gather(*tracked_tasks, return_exceptions=return_exceptions)
-        results = list(raw_results)
-
-    return results