python-async-aware-progress-bar 0.1.0__py3-none-any.whl

asyncprogress/__init__.py

@@ -0,0 +1,25 @@
+"""
+asyncprogress — Async-aware progress bar for Python asyncio applications.
+
+Provides:
+    - aprogress: async generator wrapper for iterables
+    - ProgressBar: manual async context manager
+    - MultiProgressBar: concurrent progress bars manager
+    - gather: drop-in asyncio.gather replacement with progress tracking
+    - EWMACalculator: exponential weighted moving average ETA engine
+"""
+
+from asyncprogress._bar import ProgressBar
+from asyncprogress._eta import EWMACalculator
+from asyncprogress._gather import gather
+from asyncprogress._iterator import aprogress
+from asyncprogress._multi import MultiProgressBar
+
+__version__ = "0.1.0"
+__all__ = [
+    "aprogress",
+    "ProgressBar",
+    "MultiProgressBar",
+    "gather",
+    "EWMACalculator",
+]

asyncprogress/_bar.py

@@ -0,0 +1,212 @@
+"""Core ProgressBar class: async context manager with update scheduling."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+from typing import TextIO
+
+from asyncprogress._eta import EWMACalculator
+from asyncprogress._renderer import BarRenderer
+from asyncprogress._terminal import ERASE_LINE, is_tty
+
+
+class ProgressBar:
+    """
+    Async context manager progress bar with EWMA-based ETA estimation.
+
+    Args:
+        total: Total number of items, or None for indeterminate.
+        description: Label shown before the bar.
+        bar_width: Width of the bar graphic in characters.
+        fill_char: Character for completed portion.
+        empty_char: Character for remaining portion.
+        color: ANSI color name (e.g., "green", "cyan") or None.
+        show_eta: Whether to show ETA.
+        show_elapsed: Whether to show elapsed time.
+        show_count: Whether to show item count.
+        show_percentage: Whether to show percentage.
+        update_interval: Seconds between terminal redraws.
+        ewma_alpha: EWMA smoothing factor (0 < alpha ≤ 1).
+        file: Output file (default: sys.stderr).
+        disable: If True, suppress all output.
+    """
+
+    def __init__(
+        self,
+        total: int | None = None,
+        description: str = "",
+        bar_width: int = 40,
+        fill_char: str = "█",
+        empty_char: str = "░",
+        color: str | None = None,
+        show_eta: bool = True,
+        show_elapsed: bool = True,
+        show_count: bool = True,
+        show_percentage: bool = True,
+        update_interval: float = 0.1,
+        ewma_alpha: float = 0.3,
+        file: TextIO = sys.stderr,
+        disable: bool = False,
+        _manager: object = None,
+    ) -> None:
+        self.total = total
+        self.description = description
+        self.bar_width = bar_width
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.color = color
+        self.show_eta = show_eta
+        self.show_elapsed = show_elapsed
+        self.show_count = show_count
+        self.show_percentage = show_percentage
+        self.update_interval = update_interval
+        self.file = file
+        self.disable = disable
+        self._manager = _manager
+
+        self._completed: int = 0
+        self._start_time: float = 0.0
+        self._finished: bool = False
+        self._ewma = EWMACalculator(alpha=ewma_alpha)
+        self._renderer = BarRenderer()
+        self._render_task: asyncio.Task | None = None  # type: ignore[type-arg]
+        self._last_render_time: float = 0.0
+        self._is_tty = is_tty(file)
+
+    async def __aenter__(self) -> "ProgressBar":
+        self._start_time = time.monotonic()
+        self._completed = 0
+        self._finished = False
+        self._ewma.reset()
+        if not self.disable and self._manager is None:
+            self._render_task = asyncio.get_event_loop().create_task(
+                self._render_loop()
+            )
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.finish()
+
+    async def _render_loop(self) -> None:
+        """Background task that periodically redraws the progress bar."""
+        try:
+            while not self._finished:
+                self._render()
+                await asyncio.sleep(self.update_interval)
+            # Final render after finish
+            self._render(final=True)
+        except asyncio.CancelledError:
+            self._render(final=True)
+
+    def _render(self, final: bool = False) -> None:
+        """Render the progress bar to the output file."""
+        if self.disable:
+            return
+        line = self._renderer.render(
+            description=self.description,
+            completed=self._completed,
+            total=self.total,
+            elapsed=self.elapsed,
+            eta=self.eta,
+            rate=self.rate,
+            bar_width=self.bar_width,
+            fill_char=self.fill_char,
+            empty_char=self.empty_char,
+            color=self.color,
+            show_eta=self.show_eta,
+            show_elapsed=self.show_elapsed,
+            show_count=self.show_count,
+            show_percentage=self.show_percentage,
+        )
+        if self._is_tty:
+            self.file.write(f"{ERASE_LINE}{line}")
+            if final:
+                self.file.write("\n")
+        else:
+            # Non-TTY: print milestone percentages
+            if self.total and self.total > 0:
+                pct = int(self._completed / self.total * 100)
+                milestones = [10, 20, 25, 30, 40, 50, 60, 70, 75, 80, 90, 100]
+                if pct in milestones or final:
+                    self.file.write(line + "\n")
+            elif final:
+                self.file.write(line + "\n")
+        self.file.flush()
+
+    async def update(self, n: int = 1) -> None:
+        """
+        Increment progress by n steps.
+
+        Args:
+            n: Number of steps to increment.
+        """
+        self._completed += n
+        now = time.monotonic()
+        self._ewma.record(now, self._completed)
+        if self._manager is not None:
+            # Managed bars delegate rendering to the manager
+            return
+        # Throttled direct render for non-managed bars without render loop
+        # (render loop handles periodic rendering; this is a no-op here)
+
+    async def set(self, value: int) -> None:
+        """
+        Set absolute progress to value.
+
+        Args:
+            value: Absolute progress value.
+        """
+        self._completed = value
+        now = time.monotonic()
+        self._ewma.record(now, self._completed)
+
+    async def set_description(self, description: str) -> None:
+        """
+        Update the description text dynamically.
+
+        Args:
+            description: New description string.
+        """
+        self.description = description
+
+    async def finish(self) -> None:
+        """Mark as complete regardless of current count."""
+        if self._finished:
+            return
+        self._finished = True
+        if self._render_task is not None:
+            self._render_task.cancel()
+            try:
+                await self._render_task
+            except asyncio.CancelledError:
+                pass
+            self._render_task = None
+        if not self.disable and self._manager is None:
+            self._render(final=True)
+
+    @property
+    def elapsed(self) -> float:
+        """Seconds since bar was started."""
+        if self._start_time == 0.0:
+            return 0.0
+        return time.monotonic() - self._start_time
+
+    @property
+    def eta(self) -> float | None:
+        """Estimated seconds remaining, or None if unknown."""
+        if self.total is None:
+            return None
+        remaining = max(0, self.total - self._completed)
+        return self._ewma.eta(remaining)
+
+    @property
+    def rate(self) -> float | None:
+        """Current EWMA-smoothed items/second rate."""
+        return self._ewma.rate()
+
+    @property
+    def completed(self) -> int:
+        """Number of completed items."""
+        return self._completed

asyncprogress/_eta.py

@@ -0,0 +1,77 @@
+"""EWMA-based ETA calculator for asyncprogress."""
+
+from __future__ import annotations
+
+
+class EWMACalculator:
+    """
+    Exponential Weighted Moving Average calculator for ETA estimation.
+
+    Uses EWMA over completion timestamps to produce smooth rate estimates
+    that handle bursty async I/O patterns better than simple linear regression.
+
+    Args:
+        alpha: Smoothing factor. Higher values weight recent samples more.
+               Recommended range: 0.1 (smooth) to 0.5 (reactive).
+    """
+
+    def __init__(self, alpha: float = 0.3) -> None:
+        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 | None = None
+
+    def record(self, timestamp: float, completed: int) -> None:
+        """
+        Record a completion event.
+
+        Args:
+            timestamp: Current time in seconds (e.g., from time.monotonic()).
+            completed: Total number of items completed so far.
+        """
+        if self._last_timestamp is not None and self._last_completed is not None:
+            dt = timestamp - self._last_timestamp
+            delta = completed - self._last_completed
+            if dt > 0 and delta >= 0:
+                instant_rate = delta / 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
+                    )
+        self._last_timestamp = timestamp
+        self._last_completed = completed
+
+    def rate(self) -> float | None:
+        """
+        Return smoothed items/second rate, or None if insufficient data.
+
+        Returns:
+            Smoothed rate in items/second, or None.
+        """
+        return self._ewma_rate
+
+    def eta(self, remaining: int) -> float | None:
+        """
+        Return estimated seconds to completion.
+
+        Args:
+            remaining: Number of items remaining.
+
+        Returns:
+            Estimated seconds remaining, or None if rate is unknown.
+        """
+        r = self._ewma_rate
+        if r is None or r <= 0:
+            return None
+        return remaining / r
+
+    def reset(self) -> None:
+        """Reset all state."""
+        self._ewma_rate = None
+        self._last_timestamp = None
+        self._last_completed = None

asyncprogress/_gather.py

@@ -0,0 +1,69 @@
+"""gather(): drop-in asyncio.gather replacement 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 execute concurrently.
+        description: Label shown on the progress bar.
+        return_exceptions: If True, exceptions are returned as results
+            rather than raised.
+        **progress_kwargs: Additional kwargs forwarded to ProgressBar.
+
+    Returns:
+        List of results in the same order as the input coroutines/tasks.
+    """
+    n = len(coros_or_tasks)
+    bar = ProgressBar(
+        total=n,
+        description=description,
+        **progress_kwargs,
+    )
+
+    results: list[Any] = [None] * n
+
+    async with bar:
+        tasks: list[asyncio.Task[Any]] = []
+        for coro_or_task in coros_or_tasks:
+            if isinstance(coro_or_task, asyncio.Task):
+                tasks.append(coro_or_task)
+            else:
+                tasks.append(asyncio.create_task(coro_or_task))
+
+        async def _run_and_update(
+            idx: int, task: asyncio.Task[Any]
+        ) -> None:
+            try:
+                results[idx] = await task
+            except Exception as exc:
+                if return_exceptions:
+                    results[idx] = exc
+                else:
+                    raise
+            finally:
+                await bar.update()
+
+        wrappers = [
+            asyncio.create_task(_run_and_update(i, t))
+            for i, t in enumerate(tasks)
+        ]
+        await asyncio.gather(*wrappers, return_exceptions=return_exceptions)
+
+    return results

asyncprogress/_iterator.py

@@ -0,0 +1,90 @@
+"""aprogress(): async generator wrapper for sync and async iterables."""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import AsyncIterable, AsyncIterator, Iterable
+from typing import TypeVar, Union
+
+from asyncprogress._bar import ProgressBar
+
+T = TypeVar("T")
+
+
+async def aprogress(
+    iterable: Union[AsyncIterable[T], Iterable[T]],
+    *,
+    total: int | None = None,
+    description: str = "",
+    bar_width: int = 40,
+    fill_char: str = "█",
+    empty_char: str = "░",
+    color: str | None = None,
+    show_eta: bool = True,
+    show_elapsed: bool = True,
+    show_count: bool = True,
+    show_percentage: bool = True,
+    update_interval: float = 0.1,
+    ewma_alpha: float = 0.3,
+    file: object = sys.stderr,
+    disable: bool = False,
+) -> AsyncIterator[T]:
+    """
+    Async generator wrapper that tracks progress over an iterable.
+
+    Supports both sync iterables (e.g., lists, ranges) and async iterables
+    (e.g., async generators). Auto-detects total from ``__len__`` if not
+    provided.
+
+    Args:
+        iterable: Any sync or async iterable to wrap.
+        total: Total items. Auto-detected from ``__len__`` if available.
+        description: Label shown before the bar.
+        bar_width: Width of the bar graphic in characters.
+        fill_char: Character for completed portion.
+        empty_char: Character for remaining portion.
+        color: ANSI color name or None.
+        show_eta: Whether to show ETA.
+        show_elapsed: Whether to show elapsed time.
+        show_count: Whether to show item count.
+        show_percentage: Whether to show percentage.
+        update_interval: Seconds between terminal redraws.
+        ewma_alpha: EWMA smoothing factor (0 < alpha ≤ 1).
+        file: Output file (default: sys.stderr).
+        disable: If True, suppress all output.
+
+    Yields:
+        Items from the wrapped iterable.
+    """
+    # Auto-detect total from __len__
+    if total is None and hasattr(iterable, "__len__"):
+        total = len(iterable)  # type: ignore[arg-type]
+
+    from typing import TextIO  # noqa: PLC0415
+
+    bar = ProgressBar(
+        total=total,
+        description=description,
+        bar_width=bar_width,
+        fill_char=fill_char,
+        empty_char=empty_char,
+        color=color,
+        show_eta=show_eta,
+        show_elapsed=show_elapsed,
+        show_count=show_count,
+        show_percentage=show_percentage,
+        update_interval=update_interval,
+        ewma_alpha=ewma_alpha,
+        file=file,  # type: ignore[arg-type]
+        disable=disable,
+    )
+
+    async with bar:
+        if isinstance(iterable, AsyncIterable):
+            async for item in iterable:
+                yield item
+                await bar.update()
+        else:
+            for item in iterable:  # type: ignore[union-attr]
+                yield item
+                await bar.update()

asyncprogress/_multi.py

@@ -0,0 +1,144 @@
+"""MultiProgressBar: manages multiple concurrent progress bars."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from typing import TextIO
+
+from asyncprogress._bar import ProgressBar
+from asyncprogress._terminal import ERASE_LINE, is_tty, move_cursor_up
+
+
+class MultiProgressBar:
+    """
+    Manages multiple concurrent progress bars with a shared render loop.
+
+    Args:
+        file: Output file (default: sys.stderr).
+        update_interval: Seconds between terminal redraws.
+    """
+
+    def __init__(
+        self,
+        file: TextIO = sys.stderr,
+        update_interval: float = 0.1,
+    ) -> None:
+        self.file = file
+        self.update_interval = update_interval
+        self._bars: list[ProgressBar] = []
+        self._render_task: asyncio.Task | None = None  # type: ignore[type-arg]
+        self._is_tty = is_tty(file)
+        self._lines_written: int = 0
+
+    async def __aenter__(self) -> "MultiProgressBar":
+        self._bars = []
+        self._lines_written = 0
+        self._render_task = asyncio.get_event_loop().create_task(
+            self._render_loop()
+        )
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        if self._render_task is not None:
+            self._render_task.cancel()
+            try:
+                await self._render_task
+            except asyncio.CancelledError:
+                pass
+            self._render_task = None
+        # Final render
+        self._render_all(final=True)
+
+    async def _render_loop(self) -> None:
+        """Background task that periodically redraws all progress bars."""
+        try:
+            while True:
+                self._render_all()
+                await asyncio.sleep(self.update_interval)
+        except asyncio.CancelledError:
+            pass
+
+    def _render_all(self, final: bool = False) -> None:
+        """Render all bars to the output file."""
+        if not self._bars:
+            return
+
+        lines: list[str] = []
+        for bar in self._bars:
+            import time  # noqa: PLC0415
+
+            bar._start_time = bar._start_time or time.monotonic()
+            line = bar._renderer.render(
+                description=bar.description,
+                completed=bar._completed,
+                total=bar.total,
+                elapsed=bar.elapsed,
+                eta=bar.eta,
+                rate=bar.rate,
+                bar_width=bar.bar_width,
+                fill_char=bar.fill_char,
+                empty_char=bar.empty_char,
+                color=bar.color,
+                show_eta=bar.show_eta,
+                show_elapsed=bar.show_elapsed,
+                show_count=bar.show_count,
+                show_percentage=bar.show_percentage,
+            )
+            lines.append(line)
+
+        if self._is_tty and self._lines_written > 0:
+            # Move cursor up to overwrite previous output
+            self.file.write(move_cursor_up(self._lines_written))
+
+        output = ""
+        for line in lines:
+            if self._is_tty:
+                output += f"{ERASE_LINE}{line}\n"
+            else:
+                output += line + "\n"
+
+        self.file.write(output)
+        self.file.flush()
+        self._lines_written = len(lines)
+
+    def add(
+        self,
+        description: str = "",
+        total: int | None = None,
+        **bar_kwargs: object,
+    ) -> ProgressBar:
+        """
+        Register a new progress bar.
+
+        Args:
+            description: Label for this bar.
+            total: Total items, or None for indeterminate.
+            **bar_kwargs: Additional kwargs forwarded to ProgressBar.
+
+        Returns:
+            A ProgressBar instance managed by this MultiProgressBar.
+        """
+        import time  # noqa: PLC0415
+
+        bar = ProgressBar(
+            total=total,
+            description=description,
+            file=self.file,
+            disable=False,
+            _manager=self,
+            **bar_kwargs,
+        )
+        bar._start_time = time.monotonic()
+        self._bars.append(bar)
+        return bar
+
+    def remove(self, bar: ProgressBar) -> None:
+        """
+        Remove a bar from the display.
+
+        Args:
+            bar: The ProgressBar instance to remove.
+        """
+        if bar in self._bars:
+            self._bars.remove(bar)

asyncprogress/_renderer.py

@@ -0,0 +1,102 @@
+"""Bar rendering: string formatting for progress bars."""
+
+from __future__ import annotations
+
+from asyncprogress._terminal import colorize
+
+
+def _format_time(seconds: float) -> str:
+    """Format seconds as H:MM:SS or M:SS."""
+    seconds = int(seconds)
+    h = seconds // 3600
+    m = (seconds % 3600) // 60
+    s = seconds % 60
+    if h > 0:
+        return f"{h}:{m:02d}:{s:02d}"
+    return f"{m}:{s:02d}"
+
+
+class BarRenderer:
+    """
+    Renders a single-line progress bar string.
+
+    All methods are pure (no I/O), making this fully unit-testable.
+    """
+
+    def render(
+        self,
+        *,
+        description: str,
+        completed: int,
+        total: int | None,
+        elapsed: float,
+        eta: float | None,
+        rate: float | None,
+        bar_width: int,
+        fill_char: str,
+        empty_char: str,
+        color: str | None,
+        show_eta: bool,
+        show_elapsed: bool,
+        show_count: bool,
+        show_percentage: bool,
+    ) -> str:
+        """
+        Render a single-line progress bar string.
+
+        Args:
+            description: Label text shown before the bar.
+            completed: Number of completed items.
+            total: Total items, or None for indeterminate.
+            elapsed: Seconds elapsed since start.
+            eta: Estimated seconds remaining, or None.
+            rate: Current items/second rate, or None.
+            bar_width: Width of the bar graphic in characters.
+            fill_char: Character used for completed portion.
+            empty_char: Character used for remaining portion.
+            color: ANSI color name or None.
+            show_eta: Whether to show ETA.
+            show_elapsed: Whether to show elapsed time.
+            show_count: Whether to show item count.
+            show_percentage: Whether to show percentage.
+
+        Returns:
+            A single-line string ready for terminal output.
+        """
+        parts: list[str] = []
+
+        if description:
+            parts.append(description)
+
+        if total is not None and total > 0:
+            fraction = min(completed / total, 1.0)
+            filled = int(bar_width * fraction)
+            empty = bar_width - filled
+            bar_str = fill_char * filled + empty_char * empty
+            bar_str = colorize(f"[{bar_str}]", color)
+            parts.append(bar_str)
+
+            if show_percentage:
+                parts.append(f"{fraction * 100:.0f}%")
+
+            if show_count:
+                parts.append(f"[{completed}/{total}]")
+        else:
+            # Indeterminate mode — spinning indicator
+            spinner_chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+            idx = int(elapsed * 10) % len(spinner_chars)
+            spinner = spinner_chars[idx]
+            parts.append(colorize(spinner, color))
+            if show_count:
+                parts.append(f"[{completed}]")
+
+        if show_elapsed:
+            parts.append(f"⏱ {_format_time(elapsed)}")
+
+        if show_eta:
+            if eta is not None:
+                parts.append(f"ETA: {_format_time(eta)}")
+            elif total is not None:
+                parts.append("ETA: ?")
+
+        return "  ".join(parts)

asyncprogress/_terminal.py

@@ -0,0 +1,71 @@
+"""Terminal utilities: TTY detection, ANSI escape sequences, cursor control."""
+
+from __future__ import annotations
+
+import sys
+from typing import TextIO
+
+# ANSI color codes
+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 = "\033[0m"
+CURSOR_UP = "\033[{n}A"
+ERASE_LINE = "\033[2K\r"
+CURSOR_TO_COL0 = "\r"
+
+
+def is_tty(file: TextIO = sys.stderr) -> bool:
+    """Return True if the given file is a TTY."""
+    return hasattr(file, "isatty") and file.isatty()
+
+
+def colorize(text: str, color: str | None) -> str:
+    """
+    Wrap text with ANSI color codes.
+
+    Args:
+        text: The text to colorize.
+        color: Color name (e.g., "green", "cyan") or None for no color.
+
+    Returns:
+        Colorized string, or original string if color is None/unknown.
+    """
+    if color is None:
+        return text
+    code = ANSI_COLORS.get(color.lower())
+    if code is None:
+        return text
+    return f"{code}{text}{ANSI_RESET}"
+
+
+def move_cursor_up(n: int) -> str:
+    """Return ANSI escape sequence to move cursor up n lines."""
+    return CURSOR_UP.format(n=n)
+
+
+def erase_line() -> str:
+    """Return ANSI escape sequence to erase current line."""
+    return ERASE_LINE
+
+
+def write_line(file: TextIO, text: str) -> None:
+    """Write a line to file, handling TTY vs non-TTY."""
+    file.write(text)
+    file.flush()

python_async_aware_progress_bar-0.1.0.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: python-async-aware-progress-bar
+Version: 0.1.0
+Summary: Async-aware progress bar for Python asyncio applications
+License: MIT
+License-File: LICENSE
+Keywords: asyncio,progress,progress-bar,async,tqdm
+Author: AgentSoft
+Author-email: agentsoft@example.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+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 :: Utilities
+Provides-Extra: color
+Requires-Dist: colorama (>=0.4.4) ; extra == "color"
+Description-Content-Type: text/markdown
+
+# asyncprogress
+
+An async-aware progress bar library for Python's asyncio ecosystem.
+
+[![Python](https://img.shields.io/badge/python-3.9%2B-blue)](https://python.org)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+## Overview
+
+`asyncprogress` provides first-class progress bar support for async Python code. Unlike existing solutions (tqdm, rich, alive-progress), it is designed from the ground up for `asyncio` with:
+
+- Native `async for` support
+- Accurate ETA using Exponential Weighted Moving Average (EWMA)
+- Concurrent task pool tracking
+- `await`-able context managers
+- Multiple concurrent progress bars
+- Zero mandatory runtime dependencies
+
+## Installation
+
+### Using pip
+
+

python_async_aware_progress_bar-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+asyncprogress/__init__.py,sha256=IDj9XPQWal7ek25D5aD9jufJObsqIsaogWBcu6nypFc,756
+asyncprogress/_bar.py,sha256=d1alXhxYsGnOsTqkRJ5VkV_9yCls7IMx8kFMTaEV5Dc,7061
+asyncprogress/_eta.py,sha256=Myx6LRU8FB2XV0jqfoLRvWn-Wd0tHJx5X4qWQEggpYU,2536
+asyncprogress/_gather.py,sha256=KpsV7cbs8UDGc8L1S07ajn9I8wbrafAS0Yx1ZoKHTio,2021
+asyncprogress/_iterator.py,sha256=ehkP1exBYKl38xo9HpBaujXm5KLLENf40ujybybrhe8,2874
+asyncprogress/_multi.py,sha256=r5O2UqqTsbf6s_Of_rKzIONo3Ui1f1OnbFU_eTSrDbw,4282
+asyncprogress/_renderer.py,sha256=y9fWpn0ZI6isl_bEN5cS1qbjbusuqS1JNbVwvZ5uSbs,3205
+asyncprogress/_terminal.py,sha256=8Z59rt5-nBZxA8HzXDOZaB8nljVg6mygnJT_lKhU8B4,1774
+asyncprogress/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_async_aware_progress_bar-0.1.0.dist-info/METADATA,sha256=1fN_RyrIQRydjVqYJNq_JxnztMM462CypMtT9PvUyf4,1762
+python_async_aware_progress_bar-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+python_async_aware_progress_bar-0.1.0.dist-info/licenses/LICENSE,sha256=6Y47RSQ-wXvZrjkkdspmKQ7pAlT-Qq6N6eWBjFqOjoo,1066
+python_async_aware_progress_bar-0.1.0.dist-info/RECORD,,

python_async_aware_progress_bar-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

python_async_aware_progress_bar-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AgentSoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.