asyncprogress 0.3.0__tar.gz → 0.3.1__tar.gz

{asyncprogress-0.3.0 → asyncprogress-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asyncprogress
-Version: 0.3.0
+Version: 0.3.1
 Summary: Async-aware progress bars for Python's asyncio ecosystem
 License: MIT
 License-File: LICENSE
@@ -22,22 +22,27 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: color
 Requires-Dist: colorama (>=0.4.4) ; extra == "color"
+Project-URL: Homepage, https://github.com/example/asyncprogress
+Project-URL: Repository, https://github.com/example/asyncprogress
 Description-Content-Type: text/markdown
 
 # asyncprogress
 
-Async-aware progress bars for Python's asyncio ecosystem. Zero dependencies, native `async for` support, accurate ETA with EWMA, and concurrent task tracking.
+Async-aware progress bars for Python's asyncio ecosystem. Zero mandatory dependencies.
 
-## Features
+[![PyPI](https://img.shields.io/pypi/v/asyncprogress)](https://pypi.org/project/asyncprogress/)
+[![Python](https://img.shields.io/pypi/pyversions/asyncprogress)](https://pypi.org/project/asyncprogress/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Why asyncprogress?
+
+Existing progress bar libraries (`tqdm`, `rich`, `alive-progress`) were built for synchronous code. `asyncprogress` is designed from the ground up for `asyncio`:
 
 - **Native `async for` support** — wrap any sync or async iterable
-- **`async with` context manager** — manual progress tracking
-- **`gather()` replacement** — drop-in for `asyncio.gather()` with progress
-- **`aprogress_as_completed()`** — progress-tracked `as_completed` wrapper
-- **Spinner mode** — automatic for indeterminate progress
-- **EWMA-based ETA** — accurate estimates for bursty async workloads
-- **Multiple concurrent bars** — `MultiProgressBar` for parallel streams
-- **Zero mandatory dependencies** — stdlib only
+- **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
+- **Zero mandatory dependencies** — pure stdlib `asyncio`
 
 ## Installation
 

asyncprogress-0.3.1/README.md

@@ -0,0 +1,25 @@
+# asyncprogress
+
+Async-aware progress bars for Python's asyncio ecosystem. Zero mandatory dependencies.
+
+[![PyPI](https://img.shields.io/pypi/v/asyncprogress)](https://pypi.org/project/asyncprogress/)
+[![Python](https://img.shields.io/pypi/pyversions/asyncprogress)](https://pypi.org/project/asyncprogress/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Why asyncprogress?
+
+Existing progress bar libraries (`tqdm`, `rich`, `alive-progress`) were built for synchronous code. `asyncprogress` is designed from the ground up for `asyncio`:
+
+- **Native `async for` support** — wrap any sync or async iterable
+- **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
+- **Zero mandatory dependencies** — pure stdlib `asyncio`
+
+## Installation
+
+
+
+```bash
+pip install asyncprogress
+```

{asyncprogress-0.3.0 → asyncprogress-0.3.1}/pyproject.toml

@@ -1,11 +1,12 @@
 [tool.poetry]
 name = "asyncprogress"
-version = "0.3.0"
+version = "0.3.1"
 description = "Async-aware progress bars for Python's asyncio ecosystem"
 authors = ["AgentSoft <agentsoft@example.com>"]
 readme = "README.md"
 license = "MIT"
-packages = [{include = "asyncprogress", from = "src"}]
+homepage = "https://github.com/example/asyncprogress"
+repository = "https://github.com/example/asyncprogress"
 keywords = ["asyncio", "progress", "progress-bar", "async", "tqdm"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -19,6 +20,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Framework :: AsyncIO",
 ]
+packages = [{include = "asyncprogress", from = "src"}]
 
 [tool.poetry.dependencies]
 python = "^3.9"
@@ -40,7 +42,18 @@ build-backend = "poetry.core.masonry.api"
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]
-addopts = "--cov=src/asyncprogress --cov-report=term-missing --cov-fail-under=80"
+addopts = "--cov=asyncprogress --cov-report=term-missing --cov-fail-under=80"
+
+[tool.coverage.run]
+source = ["src/asyncprogress"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+]
 
 [tool.ruff]
 line-length = 100
@@ -49,7 +62,3 @@ target-version = "py39"
 [tool.ruff.lint]
 select = ["E", "F", "W", "I", "UP"]
 ignore = ["E501"]
-
-[tool.coverage.run]
-source = ["src/asyncprogress"]
-omit = ["*/tests/*"]

{asyncprogress-0.3.0 → asyncprogress-0.3.1}/src/asyncprogress/__init__.py

@@ -1,8 +1,7 @@
 """
 asyncprogress — Async-aware progress bars for Python's asyncio ecosystem.
 
-Zero dependencies, native async for support, accurate EWMA-based ETA,
-and concurrent task tracking.
+Zero mandatory dependencies. Pure stdlib asyncio.
 """
 
 from __future__ import annotations
@@ -14,13 +13,13 @@ from asyncprogress._gather import gather
 from asyncprogress._iterator import aprogress
 from asyncprogress._multi import MultiProgressBar
 
+__version__ = "0.3.1"
+
 __all__ = [
     "aprogress",
-    "ProgressBar",
-    "MultiProgressBar",
-    "gather",
-    "EWMACalculator",
     "aprogress_as_completed",
+    "EWMACalculator",
+    "gather",
+    "MultiProgressBar",
+    "ProgressBar",
 ]
-
-__version__ = "0.3.0"

{asyncprogress-0.3.0 → asyncprogress-0.3.1}/src/asyncprogress/_eta.py

@@ -11,8 +11,8 @@ class EWMACalculator:
     """
     Exponential Weighted Moving Average calculator for ETA estimation.
 
-    Uses EWMA over completion timestamps rather than simple linear regression,
-    which better accounts for burst patterns common in async I/O workloads.
+    Uses EWMA over completion rates rather than simple linear regression,
+    which handles bursty async I/O patterns more accurately.
 
     Args:
         alpha: Smoothing factor. Higher = more weight on recent samples.
@@ -40,16 +40,16 @@ class EWMACalculator:
                     self._ewma_rate = (
                         self._alpha * instant_rate + (1 - self._alpha) * self._ewma_rate
                     )
-            # If dt == 0, skip this sample (same timestamp)
+            # If dt == 0, don't update rate (avoid division by zero)
         self._last_timestamp = timestamp
         self._last_completed = completed
 
     def rate(self) -> float | None:
-        """Return smoothed items/second, or None if insufficient data."""
+        """Returns smoothed items/second, or None if insufficient data."""
         return self._ewma_rate
 
     def eta(self, remaining: int) -> float | None:
-        """Return estimated seconds to completion, or None if unknown."""
+        """Returns estimated seconds to completion, or None if unknown."""
         if remaining == 0:
             return 0.0
         r = self.rate()

{asyncprogress-0.3.0 → asyncprogress-0.3.1}/src/asyncprogress/_renderer.py

@@ -6,39 +6,38 @@ String formatting only; no I/O. Fully unit-testable.
 
 from __future__ import annotations
 
-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"
-
 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_RESET = "\x1b[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."""
-    code = ANSI_COLORS.get(color.lower(), "")
+    """Apply ANSI color to text, returning reset at end."""
+    code = _ANSI_COLORS.get(color.lower(), "")
     if not code:
         return text
-    return f"{code}{text}{ANSI_RESET}"
+    return f"{code}{text}{_ANSI_RESET}"
 
 
 def _format_duration(seconds: float) -> str:
@@ -64,24 +63,24 @@ class BarRenderer:
     """
     Renders progress bar strings for terminal output.
 
-    No I/O performed here — returns strings only.
+    String formatting only — no I/O performed here.
     """
 
     def _compute_percentage(self, completed: int, total: int) -> float:
-        """Compute percentage, handling zero total."""
+        """Compute percentage, handling total=0 gracefully."""
         if total == 0:
-            return 100.0
+            return 100.0  # Empty collection is trivially complete
         return min(100.0, (completed / total) * 100.0)
 
     def _format_count(
         self,
         completed: int,
         total: int | None,
-        unit: str = "it",
-        unit_scale: bool = False,
-        unit_divisor: int = 1000,
+        unit: str,
+        unit_scale: bool,
+        unit_divisor: int,
     ) -> str:
-        """Format the count display string."""
+        """Format the count portion of the bar."""
         if not unit_scale:
             if total is not None:
                 return f"[{completed}/{total} {unit}]"
@@ -95,17 +94,17 @@ class BarRenderer:
     def _format_rate(
         self,
         rate: float | None,
-        unit: str = "it",
-        unit_scale: bool = False,
-        unit_divisor: int = 1000,
+        unit: str,
+        unit_scale: bool,
+        unit_divisor: int,
     ) -> str:
-        """Format the rate display string."""
+        """Format the rate portion of the bar."""
         if rate is None:
             return ""
         if not unit_scale:
             return f"{rate:.1f} {unit}/s"
-        val, prefix = _scale_value(rate, unit_divisor)
-        return f"{val:.1f} {prefix}{unit}/s"
+        r_val, r_prefix = _scale_value(rate, unit_divisor)
+        return f"{r_val:.1f} {r_prefix}{unit}/s"
 
     def render(
         self,
@@ -135,44 +134,41 @@ class BarRenderer:
         """
         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} ")
+            filled = int(bar_width * pct / 100) if bar_width > 0 else 0
+            bar_str = fill_char * filled + empty_char * (bar_width - filled)
+            parts.append(f" {bar_str} ")
 
-            # 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))
+                parts.append(
+                    self._format_count(completed, total, unit, unit_scale, unit_divisor)
+                )
         else:
             # Indeterminate — no bar graphic
             if show_count:
-                parts.append(self._format_count(completed, None, unit, unit_scale, unit_divisor))
+                parts.append(
+                    self._format_count(completed, None, unit, unit_scale, unit_divisor)
+                )
 
-        # Elapsed
         if show_elapsed:
             parts.append(f"⏱ {_format_duration(elapsed)}")
 
-        # ETA
         if show_eta and eta is not None:
             parts.append(f"ETA: {_format_duration(eta)}")
 
-        # Rate
         if rate is not None:
             rate_str = self._format_rate(rate, unit, unit_scale, unit_divisor)
             if rate_str:
                 parts.append(rate_str)
 
-        line = " ".join(parts)
+        line = " ".join(p for p in parts if p)
         if color:
             line = _apply_color(line, color)
         return line

{asyncprogress-0.3.0 → asyncprogress-0.3.1}/src/asyncprogress/_terminal.py

@@ -1,5 +1,5 @@
 """
-Terminal utilities: TTY detection, ANSI cursor control sequences.
+Terminal utilities — TTY detection and ANSI escape sequences.
 """
 
 from __future__ import annotations
@@ -10,29 +10,24 @@ from typing import TextIO
 
 def is_tty(file: TextIO = sys.stderr) -> bool:
     """Return True if the given file is a TTY."""
-    try:
-        return file.isatty()
-    except AttributeError:
-        return False
+    return hasattr(file, "isatty") and file.isatty()
 
 
 def move_cursor_up(n: int = 1) -> str:
     """Return ANSI escape sequence to move cursor up n lines."""
-    if n <= 0:
-        return ""
-    return f"\033[{n}A"
+    return f"\x1b[{n}A"
 
 
 def erase_line() -> str:
     """Return ANSI escape sequence to erase the current line."""
-    return "\033[2K\r"
+    return "\x1b[2K\r"
 
 
 def hide_cursor() -> str:
     """Return ANSI escape sequence to hide the cursor."""
-    return "\033[?25l"
+    return "\x1b[?25l"
 
 
 def show_cursor() -> str:
     """Return ANSI escape sequence to show the cursor."""
-    return "\033[?25h"
+    return "\x1b[?25h"

asyncprogress-0.3.0/README.md

@@ -1,22 +0,0 @@
-# asyncprogress
-
-Async-aware progress bars for Python's asyncio ecosystem. Zero dependencies, native `async for` support, accurate ETA with EWMA, and concurrent task tracking.
-
-## Features
-
-- **Native `async for` support** — wrap any sync or async iterable
-- **`async with` context manager** — manual progress tracking
-- **`gather()` replacement** — drop-in for `asyncio.gather()` with progress
-- **`aprogress_as_completed()`** — progress-tracked `as_completed` wrapper
-- **Spinner mode** — automatic for indeterminate progress
-- **EWMA-based ETA** — accurate estimates for bursty async workloads
-- **Multiple concurrent bars** — `MultiProgressBar` for parallel streams
-- **Zero mandatory dependencies** — stdlib only
-
-## Installation
-
-
-
-```bash
-pip install asyncprogress
-```