processit 0.0.1__tar.gz

processit-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vicente Ruiz
+
+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.

processit-0.0.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: processit
+Version: 0.0.1
+Summary: Process It
+Author: Vicente Ruiz
+License: MIT License
+        
+        Copyright (c) 2025 Vicente Ruiz
+        
+        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.
+        
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file

processit-0.0.1/README.md

@@ -0,0 +1,234 @@
+# processit
+
+A lightweight progress utility for Python — built for both synchronous and asynchronous iteration.
+
+`processit` provides a simple, dependency-free progress bar for loops that may be either regular iterables or async iterables.
+
+---
+
+## Installation
+
+```bash
+pip install processit
+```
+
+---
+
+## Quick Example
+
+### progress
+
+```python
+import asyncio
+import time
+
+from processit import progress
+
+def numbers():
+    for i in range(10):
+        time.sleep(0.3)
+        yield i
+
+async def main():
+    async for _ in progress(numbers(), total=10, desc="Numbers"):
+        await asyncio.sleep(0)
+
+asyncio.run(main())
+```
+
+```
+Numbers [#############.................]  50.00% (5/10) 4.92 it/s 02.1s ETA 02.1s
+Numbers: 10 it in 04.1s (2.43 it/s)
+```
+
+```python
+import asyncio
+import time
+
+from processit import progress
+
+def numbers():
+    for i in range(10):
+        time.sleep(0.3)
+        yield i
+
+async def main():
+    async with progress(numbers(), total=10, desc='Numbers') as p:
+        async for n in p:
+            p.write(f'value: {n}')
+            await asyncio.sleep(0.5)
+
+
+asyncio.run(main())
+```
+
+### track_as_completed
+
+```python
+import asyncio
+import random
+
+from processit import track_as_completed
+
+async def work(n: int) -> int:
+    await asyncio.sleep(1.5 + random.random())
+    return n * 2
+
+async def main():
+    tasks = [work(i) for i in range(10)]
+    async for fut in track_as_completed(tasks, desc="Parallel work"):
+        await fut
+
+asyncio.run(main())
+```
+
+```
+Parallel work [#####################.........]  70.00% (7/10) 68.68 it/s 00.1s ETA 00.0s14
+Parallel work: 10 it in 00.1s (98.01 it/s)
+```
+
+```python
+import asyncio
+
+from processit import track_as_completed
+
+async def work(i: int) -> int:
+    await asyncio.sleep(2)
+    return i * 2
+
+async def main():
+    tasks = [work(i) for i in range(10)]
+    async with track_as_completed(tasks, desc="Parallel work") as p:
+        async for task in p:       # itera mientras re-renderiza
+            result = await task
+            p.write(f"done: {result}")  # en vez de print(result)
+            await asyncio.sleep(2)
+
+asyncio.run(main())
+```
+
+## More examples
+
+### Asynchronous iteration over a data source
+
+```python
+import asyncio
+
+from processit import progress
+
+async def fetch_items():
+    for i in range(20):
+        await asyncio.sleep(0.05)
+        yield f"item-{i}"
+
+async def main():
+    async for item in progress(fetch_items(), total=20, desc="Fetching"):
+        await asyncio.sleep(0.02)
+
+asyncio.run(main())
+```
+
+### Processing a list without a defined total
+
+```python
+import asyncio
+
+from processit import progress
+
+items = [x ** 2 for x in range(100)]
+
+async def main():
+    async for value in progress(items, desc="Squaring"):
+        await asyncio.sleep(0.01)
+
+asyncio.run(main())
+```
+
+### Using an async with context
+
+```python
+import asyncio
+
+from processit import progress
+
+async def numbers():
+    for i in range(8):
+        await asyncio.sleep(0.1)
+        yield i
+
+async def main():
+    async with progress(numbers(), total=8, desc="Context mode") as p:
+        async for n in p:
+            await asyncio.sleep(0.05)
+
+asyncio.run(main())
+```
+
+### Synchronous iterator in an asynchronous environment
+
+```python
+import asyncio
+import time
+
+from processit import progress
+
+def blocking_iter():
+    for i in range(5):
+        time.sleep(0.4)
+        yield i
+
+async def main():
+    async for n in progress(blocking_iter(), total=5, desc="Blocking loop"):
+        await asyncio.sleep(0)
+
+asyncio.run(main())
+```
+
+---
+
+## Features
+
+✅ Works with both **async** and **sync** iterables
+✅ Displays **elapsed time**, **rate**, and **ETA** (when total is known)
+✅ Automatically cleans up and prints a **final summary**
+✅ **No dependencies** — pure Python, fully type-hinted
+✅ Easy to use drop-in function: `progress(iterable, ...)`
+
+---
+
+## API
+
+### `progress(iterable, total=None, *, desc='Processing', width=30, refresh_interval=0.1, show_summary=True)`
+
+Creates and returns a `Progress` instance.
+
+#### Parameters
+| Name | Type | Description |
+|------|------|-------------|
+| `iterable` | `Iterable[T] | AsyncIterable[T]` | The iterable or async iterable to track. |
+| `total` | `int | None` | Total number of iterations (optional). |
+| `desc` | `str` | A short description shown before the bar. |
+| `width` | `int` | Width of the progress bar (default: 30). |
+| `refresh_interval` | `float` | Time in seconds between updates. |
+| `show_summary` | `bool` | Whether to show a final summary line (default: `True`). |
+
+---
+
+## Usage with Regular Iterables
+
+```python
+from processit import progress
+import time
+
+def numbers():
+    for i in range(5):
+        time.sleep(0.3)
+        yield i
+
+async def main():
+    async for n in progress(numbers(), total=5, desc="Sync loop"):
+        await asyncio.sleep(0)
+
+import asyncio
+asyncio.run(main())
+```

processit-0.0.1/pyproject.toml

@@ -0,0 +1,144 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "processit"
+dynamic = ["version"]
+description = "Process It"
+authors = [{name = "Vicente Ruiz"}]
+license = {file = "LICENSE"}
+dependencies = []
+
+[tool.setuptools.dynamic]
+version = {attr = "processit._version.__version__"}
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "pytest-cov>=5.0",
+    "ruff>=0.5.0",
+    "mypy>=1.10",
+]
+
+[tool.ruff]
+# Exclude directories.
+exclude = [
+    ".git",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".vscode",
+    "build",
+    "dist",
+    "site-packages",
+    "env",
+]
+respect-gitignore = true
+
+line-length = 79
+indent-width = 4
+target-version = "py313"
+src = ["src", "tests"]
+
+
+[tool.ruff.lint]
+
+select = [
+    "E",     # pycodestyle
+    "D",     # pydocstyle
+    "F",     # Pyflakes
+    "I",     # isort
+    "N",     # pep8-naming
+    "PL",    # pylint
+    "UP",    # pyupgrade
+    "A",     # flake8-builtins
+    "ASYNC", # flake8-async
+    "S",     # flake8-bandit
+    "FBT",   # flake8-boolean-trap
+    "B",     # flake8-bugbear
+    "A",     # flake8-builtins
+    "COM",   # flake8-commas
+    "C4",    # flake8-comprehensions
+    "DTZ",   # flake8-datetimez
+    "T10",   # flake8-debugger
+    "EM",    # flake8-errmsg
+    "FA",    # flake8-future-annotations
+    "ISC",   # flake8-implicit-str-concat
+    "ICN",   # flake8-import-conventions
+    "PIE",   # flake8-pie
+    "T20",   # flake8-print
+    "PYI",   # flake8-pyi
+    "PT",    # flake8-pytest-style
+    "RSE",   # flake8-raise
+    "RET",   # flake8-return
+    "SLOT",  # flake8-slots
+    "SIM",   # flake8-simplify
+    "TC",    # flake8-type-checking
+    "INT",   # flake8-gettext
+    "PTH",   # flake8-use-pathlib
+    "PERF",  # Perflint
+    "FURB",  # refurb
+    "RUF",   # Ruff specific
+]
+ignore = [
+    "D100",  # Missing docstring in public module
+    "D104",  # Missing docstring in public package
+    "D105",  # Missing docstring in magic method
+    "D107",  # Missing docstring in `__init__`
+
+    "D101",  # Missing docstring in public class
+    "D102",  # Missing docstring in public method
+    "D103",  # Missing docstring in public function
+]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+"scripts/generate_avatar_dataset.py" = ["S320", "T201"]
+
+[tool.ruff.lint.flake8-pytest-style]
+parametrize-names-type = "list"        # @pytest.mark.parametrize(['name1', 'name2'], ...)
+parametrize-values-row-type = "tuple"  # @pytest.mark.parametrize(['name1', 'name2'], [(1, 2), (3, 4)])
+parametrize-values-type = "list"       # @pytest.mark.parametrize('name', [1, 2, 3])
+
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+ignore-decorators = ["typing.overload"]
+
+
+[tool.ruff.lint.isort]
+section-order = ["future", "standard-library", "third-party", "first-party", "local-folder"]
+combine-as-imports = true
+lines-between-types = 1
+lines-after-imports = 2
+forced-separate = ["tests"]
+force-sort-within-sections = false
+
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"
+
+# Respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"

processit-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

processit-0.0.1/src/processit/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from processit._version import __version__
+from processit.progress import progress, track_as_completed
+
+
+__all__ = ('__version__', 'progress', 'track_as_completed')

processit-0.0.1/src/processit/_version.py

@@ -0,0 +1,2 @@
+version_info: tuple[int | str, ...] = (0, 0, 1)
+__version__ = '.'.join(map(str, version_info))

processit-0.0.1/src/processit/progress.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import sys
+import time
+
+from typing import TYPE_CHECKING, TextIO, cast
+
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        AsyncIterable,
+        AsyncIterator,
+        Awaitable,
+        Iterable,
+    )
+
+
+class Progress[T]:
+    __slots__ = (
+        '_is_tty',
+        '_last_line_len',
+        '_last_refresh',
+        '_next_render_at',
+        '_prefix',
+        '_refresh_task',
+        '_stopped',
+        '_summary_printed',
+        'count',
+        'desc',
+        'iterable',
+        'refresh_interval',
+        'show_summary',
+        'start_time',
+        'stream',
+        'total',
+        'width',
+    )
+
+    def __init__(  # noqa: PLR0913
+        self,
+        iterable: Iterable[T] | AsyncIterable[T],
+        total: int | None = None,
+        *,
+        desc: str = 'Processing',
+        width: int = 30,
+        stream: TextIO | None = None,
+        refresh_interval: float = 0.1,
+        show_summary: bool = True,
+    ) -> None:
+        self.iterable = iterable
+        self.total = total
+        self.desc = desc
+        self.width = width
+        self.stream = stream or sys.stderr
+        self.refresh_interval = refresh_interval
+        self.show_summary = show_summary
+
+        self.count = 0
+        self.start_time = time.perf_counter()
+        self._last_refresh = 0.0
+        self._next_render_at = 0.0  # render inmediato al inicio
+        self._refresh_task: asyncio.Task[None] | None = None
+        self._summary_printed = False
+        self._last_line_len = 0
+        self._stopped = False
+        self._is_tty = bool(getattr(self.stream, 'isatty', lambda: False)())
+        self._prefix = f'{self.desc} '
+
+    def write(self, msg: str = '') -> None:
+        """Print a message below the bar and re-render it (TTY-safe)."""
+        if self._stopped:
+            return
+        self._clear_line()
+        if msg:
+            if not msg.endswith('\n'):
+                msg += '\n'
+            self.stream.write(msg)
+            self.stream.flush()
+        self._render(force=True)
+
+    def _format_elapsed(self, seconds: float) -> str:
+        """Return hh:mm:ss, mm:ss or ss.s depending on duration."""
+        if seconds < 60:  # noqa: PLR2004
+            return f'{seconds:04.1f}s'
+        minutes, secs = divmod(int(seconds), 60)
+        if minutes < 60:  # noqa: PLR2004
+            return f'{minutes:02d}:{secs:02d}'
+        hours, minutes = divmod(minutes, 60)
+        return f'{hours:02d}:{minutes:02d}:{secs:02d}'
+
+    def _write_line(self, text: str) -> None:
+        if self._is_tty:
+            # \r = return, \x1b[2K = clear whole line (ANSI)
+            self.stream.write('\r\x1b[2K' + text)
+            self.stream.flush()
+            self._last_line_len = len(text)
+        else:
+            # non-TTY (StringIO/logs): one line per render for deterministic
+            # tests/logs
+            self.stream.write(text + '\n')
+            self.stream.flush()
+            self._last_line_len = 0
+
+    def _clear_line(self) -> None:
+        if self._is_tty:
+            self.stream.write('\r\x1b[2K')
+            self.stream.flush()
+            self._last_line_len = 0
+        else:
+            # non-TTY: renders are on separate lines; nothing to clear
+            pass
+
+    def _should_render(self, now: float) -> bool:
+        # Permite render al inicio (_next_render_at=0) o si ha
+        # pasado refresh_interval
+        return now >= self._next_render_at or self._last_line_len == 0
+
+    def _render(self, *, force: bool = False) -> None:
+        if self._stopped:
+            return
+
+        now = time.perf_counter()
+        if not force and not self._should_render(now):
+            return
+
+        elapsed = now - self.start_time
+        rate = self.count / elapsed if elapsed > 0 else 0.0
+        elapsed_str = self._format_elapsed(elapsed)
+
+        eta_str = ''
+        if self.total is not None and self.count > 0 and rate > 0:
+            remaining = max(self.total - self.count, 0)
+            eta = remaining / rate
+            eta_str = f' ETA {self._format_elapsed(eta)}'
+
+        if self.total:
+            frac = min(self.count / self.total, 1.0)
+            filled = int(self.width * frac)
+            bar = f'[{"#" * filled}{"." * (self.width - filled)}]'
+            percent = f'{frac * 100:6.2f}%'
+            line = (
+                f'{self._prefix}{bar} {percent} '
+                f'({self.count}/{self.total}) {rate:.2f} it/s '
+                f'{elapsed_str}{eta_str}'
+            )
+        else:
+            line = (
+                f'{self._prefix}{self.count} it '
+                f'({rate:.2f} it/s {elapsed_str})'
+            )
+
+        self._write_line(line)
+        self._last_refresh = now
+        self._next_render_at = now + self.refresh_interval
+
+    def _print_summary_if_needed(self) -> None:
+        if self.show_summary and not self._summary_printed:
+            self._stopped = True
+            self._clear_line()
+
+            elapsed = time.perf_counter() - self.start_time
+            rate = self.count / elapsed if elapsed > 0 else 0.0
+            elapsed_str = self._format_elapsed(elapsed)
+
+            self.stream.write(
+                f'{self.desc}: {self.count} it in {elapsed_str} '
+                f'({rate:.2f} it/s)\n',
+            )
+            self.stream.flush()
+            self._summary_printed = True
+
+    async def _refresh_periodically(self) -> None:
+        while not self._stopped:
+            await asyncio.sleep(self.refresh_interval)
+            if self._stopped:
+                break
+            self._render()
+
+    async def __aenter__(self) -> Progress[T]:
+        self._stopped = False
+        self._render(force=True)  # feedback inmediato
+        self._refresh_task = asyncio.create_task(self._refresh_periodically())
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        if self._refresh_task is not None:
+            self._refresh_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._refresh_task
+            self._refresh_task = None
+        self._print_summary_if_needed()
+
+    async def __aiter__(self) -> AsyncIterator[T]:
+        started_here = False
+
+        if self._refresh_task is None:
+            self._stopped = False
+            self._render(
+                force=True,
+            )  # feedback inmediato fuera de context manager
+            self._refresh_task = asyncio.create_task(
+                self._refresh_periodically(),
+            )
+            started_here = True
+
+        try:
+            if hasattr(self.iterable, '__aiter__'):
+                async for item in cast('AsyncIterable[T]', self.iterable):
+                    self.count += 1
+                    self._render()
+                    yield item
+            else:
+                for item in cast('Iterable[T]', self.iterable):
+                    self.count += 1
+                    self._render()
+                    yield item
+                    # cede el loop para no bloquear el refresco
+                    await asyncio.sleep(0)
+        finally:
+            if started_here and self._refresh_task is not None:  # type: ignore
+                self._refresh_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await self._refresh_task
+                self._refresh_task = None
+            self._print_summary_if_needed()
+
+
+def progress[T](  # noqa: PLR0913
+    iterable: Iterable[T] | AsyncIterable[T],
+    total: int | None = None,
+    *,
+    desc: str = 'Processing',
+    width: int = 30,
+    refresh_interval: float = 0.1,
+    show_summary: bool = True,
+    stream: TextIO | None = None,
+) -> Progress[T]:
+    """Wrap an iterable or async iterable with a progress bar.
+
+    Parameters
+    ----------
+    iterable: Iterable[T] | AsyncIterable[T]
+        The iterable or async iterable to iterate over.
+    total: int | None, optional
+        Total number of elements. If not provided and `iterable` has
+        `__len__`, it will be inferred automatically. Otherwise, ETA
+        will not be displayed.
+    desc: str, optional
+        A short description displayed before the progress bar.
+    width: int, optional
+        The width (in characters) of the progress bar (default: 30).
+    refresh_interval: float, optional
+        Minimum time interval in seconds between display refreshes.
+    show_summary: bool, optional
+        Whether to print a final summary line showing total iterations,
+        total time, and iteration rate (default: True).
+    stream: TextIO | None, optional
+        Output stream to render the bar (default: sys.stderr).
+
+    Yields:
+    ------
+    T
+        Each element from the iterable or async iterable, in order.
+    """
+    # Infer total if possible
+    if total is None and hasattr(iterable, '__len__'):
+        try:
+            total = len(iterable)  # type: ignore[arg-type]
+        except Exception:
+            total = None
+
+    return Progress(
+        iterable,
+        total,
+        desc=desc,
+        width=width,
+        refresh_interval=refresh_interval,
+        show_summary=show_summary,
+        stream=stream,
+    )
+
+
+def track_as_completed[T](  # noqa: PLR0913
+    tasks: Iterable[Awaitable[T]],
+    *,
+    total: int | None = None,
+    desc: str = 'Processing',
+    width: int = 30,
+    refresh_interval: float = 0.1,
+    show_summary: bool = True,
+    stream: TextIO | None = None,
+) -> Progress[asyncio.Future[T]]:
+    """Iterate results as tasks complete, with a progress bar.
+
+    Parameters
+    ----------
+    tasks: Iterable[Awaitable[T]]
+        Awaitables or tasks to run/track.
+    total: int | None, optional
+        Total number of tasks. If not provided and `tasks` has `__len__`,
+        it will be inferred. Otherwise, ETA will not be shown.
+    desc: str
+        Short description prefix for the bar.
+    width: int
+        Progress bar width (characters).
+    refresh_interval: float
+        Seconds between refreshes.
+    show_summary: bool
+        Whether to print a final summary line.
+    stream: TextIO | None, optional
+        Output stream to render the bar (default: sys.stderr).
+
+    Returns:
+    -------
+    Progress[Future[T]]
+        An async-iterable of **futures** (await them in the loop).
+
+    Notes:
+    -----
+    We *avoid* passing the synchronous iterator from
+    `asyncio.as_completed(...)` directly to `Progress`, since its `next()` can
+    block the event loop. Instead, we drive completion asynchronously using
+    `asyncio.wait(FIRST_COMPLETED)`.
+    """
+    # Infer total if possible
+    if total is None and hasattr(tasks, '__len__'):
+        try:
+            total = len(tasks)  # type: ignore[arg-type]
+        except Exception:
+            total = None
+
+    async def _as_completed_async() -> AsyncIterable[asyncio.Future[T]]:
+        pending: set[asyncio.Future[T]] = {
+            asyncio.ensure_future(t)
+            for t in tasks  # type: ignore[arg-type]
+        }
+        try:
+            while pending:
+                done, pending = await asyncio.wait(
+                    pending,
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for fut in done:
+                    yield fut
+        finally:
+            # No cancelamos 'pending' por defecto (el consumidor decide su
+            # ciclo de vida).
+            pass
+
+    return progress(
+        _as_completed_async(),
+        total=total,
+        desc=desc,
+        width=width,
+        refresh_interval=refresh_interval,
+        show_summary=show_summary,
+        stream=stream,
+    )

processit-0.0.1/src/processit.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: processit
+Version: 0.0.1
+Summary: Process It
+Author: Vicente Ruiz
+License: MIT License
+        
+        Copyright (c) 2025 Vicente Ruiz
+        
+        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.
+        
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file

processit-0.0.1/src/processit.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/processit/__init__.py
+src/processit/_version.py
+src/processit/progress.py
+src/processit/py.typed
+src/processit.egg-info/PKG-INFO
+src/processit.egg-info/SOURCES.txt
+src/processit.egg-info/dependency_links.txt
+src/processit.egg-info/requires.txt
+src/processit.egg-info/top_level.txt
+tests/test_progress.py

processit-0.0.1/src/processit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

processit-0.0.1/src/processit.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.24
+pytest-cov>=5.0
+ruff>=0.5.0
+mypy>=1.10

processit-0.0.1/src/processit.egg-info/top_level.txt

@@ -0,0 +1 @@
+processit

processit-0.0.1/tests/test_progress.py

@@ -0,0 +1,331 @@
+# tests/test_processit.py
+from __future__ import annotations
+
+import asyncio
+import io
+import time
+
+from typing import TYPE_CHECKING
+
+import pytest
+
+from processit.progress import Progress, progress, track_as_completed
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Iterator
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
+
+
+def _strip_ansi(s: str) -> str:
+    # El progreso usa \r y \x1b[2K; limpiamos para aserciones más simples
+    s = s.replace('\r', '')
+    return s.replace('\x1b[2K', '')
+
+
+def _last_nonempty_line(buf: str) -> str:
+    for line in reversed(buf.splitlines()):
+        if line.strip():
+            return line
+    return ''
+
+
+# -----------------------------
+# Synchronous iterable cases
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_sync_iterable_basic_summary_only_once():
+    stream = io.StringIO()
+
+    def numbers() -> Iterator[int]:
+        for i in range(5):
+            time.sleep(0.01)
+            yield i
+
+    # Consumo como async for (la clase cede el loop con await asyncio.sleep(0))
+    async for _ in progress(
+        numbers(),
+        desc='Numbers',
+        total=5,
+        stream=stream,
+        refresh_interval=1.0,
+    ):
+        await asyncio.sleep(0)
+
+    out = _strip_ansi(stream.getvalue())
+    # Debe haber un único resumen final
+    assert out.count('Numbers: 5 it in ') == 1
+    assert 'it/s' in out
+
+
+@pytest.mark.asyncio
+async def test_sync_iterable_infers_total_from_len():
+    stream = io.StringIO()
+    data = list(range(4))  # tiene __len__
+    async for _ in progress(
+        data,
+        desc='Len inf',
+        stream=stream,
+        refresh_interval=1.0,
+    ):
+        await asyncio.sleep(0)
+    out = stream.getvalue()
+    # En algún render debe aparecer (4/4)
+    assert '(4/4)' in out
+
+
+# -----------------------------
+# Async iterable cases
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_async_iterable_basic():
+    stream = io.StringIO()
+
+    async def agen() -> AsyncIterator[int]:
+        for i in range(6):
+            await asyncio.sleep(0.01)
+            yield i
+
+    async for _ in progress(
+        agen(),
+        total=6,
+        desc='Agen',
+        stream=stream,
+        refresh_interval=1.0,
+    ):
+        await asyncio.sleep(0)
+
+    out = _strip_ansi(stream.getvalue())
+    assert out.count('Agen: 6 it in ') == 1
+    assert 'it/s' in out
+
+
+@pytest.mark.asyncio
+async def test_async_iterable_without_total():
+    stream = io.StringIO()
+
+    async def agen() -> AsyncIterator[int]:
+        for i in range(3):
+            await asyncio.sleep(0.005)
+            yield i
+
+    # Sin total explícito; el resumen siempre debe estar
+    async for _ in progress(
+        agen(),
+        desc='No total',
+        stream=stream,
+        refresh_interval=1.0,
+    ):
+        await asyncio.sleep(0)
+
+    out = _strip_ansi(stream.getvalue())
+    assert 'No total: 3 it in ' in out
+    # No forzamos presencia de '%' porque sin total no hay porcentaje en barra
+
+
+# -----------------------------
+# Context manager + write()
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_async_with_and_write_no_extra_bar_at_end():
+    stream = io.StringIO()
+
+    def numbers() -> Iterator[int]:
+        for i in range(5):
+            time.sleep(0.01)
+            yield i
+
+    async with progress(
+        numbers(),
+        total=5,
+        desc='With',
+        stream=stream,
+        refresh_interval=1.0,
+    ) as p:
+        async for n in p:
+            p.write(f'value: {n}')
+            await asyncio.sleep(0)
+
+    out = _strip_ansi(stream.getvalue())
+    # El último renglón no debe ser una barra, sino el resumen
+    last = _last_nonempty_line(out)
+    assert last.startswith('With: 5 it in ')
+    # Y que no haya texto de barra después del resumen
+    assert 'With [' not in last
+
+
+# -----------------------------
+# track_as_completed cases
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_track_as_completed_varied_durations():
+    stream = io.StringIO()
+
+    async def work(n: int) -> int:
+        # Duraciones variadas: 0.01..0.06
+        await asyncio.sleep(0.01 * (n % 6 + 1))
+        return n
+
+    tasks = [work(i) for i in range(10)]
+
+    # Itera devolviendo futuros; hacemos await dentro del bucle
+    async for fut in track_as_completed(
+        tasks,
+        desc='Parallel',
+        stream=stream,
+        refresh_interval=0.02,
+    ):
+        _ = await fut  # procesar resultado
+
+    out = _strip_ansi(stream.getvalue())
+    assert 'Parallel: 10 it in ' in out
+
+
+@pytest.mark.asyncio
+async def test_track_as_completed_equal_durations_still_counts():
+    stream = io.StringIO()
+
+    async def work(n: int) -> int:
+        await asyncio.sleep(0.02)  # todas igual
+        return n
+
+    tasks = [work(i) for i in range(8)]
+    async for fut in track_as_completed(
+        tasks,
+        desc='Equal',
+        stream=stream,
+        refresh_interval=0.02,
+    ):
+        _ = await fut
+
+    out = _strip_ansi(stream.getvalue())
+    assert 'Equal: 8 it in ' in out
+
+
+# -----------------------------
+# show_summary flag
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_show_summary_false():
+    stream = io.StringIO()
+    data = [1, 2, 3]
+    async for _ in progress(
+        data,
+        desc='NoSum',
+        show_summary=False,
+        stream=stream,
+        refresh_interval=1.0,
+    ):
+        await asyncio.sleep(0)
+    out = _strip_ansi(stream.getvalue())
+    # No debe haber resumen
+    assert 'NoSum: 3 it in ' not in out
+
+
+# -----------------------------
+# stream wiring & basic type use
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_progress_stream_stdout_like():
+    # Simulamos sys.stdout con StringIO
+    stream = io.StringIO()
+
+    async def agen():
+        for i in range(2):
+            await asyncio.sleep(0.005)
+            yield i
+
+    async for _ in progress(
+        agen(),
+        total=2,
+        desc='Stdout',
+        stream=stream,
+        refresh_interval=1.0,
+    ):
+        pass
+    out = _strip_ansi(stream.getvalue())
+    assert 'Stdout: 2 it in ' in out
+
+
+# -----------------------------
+# smoke test: Progress usable directamente
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_progress_class_direct_use():
+    stream = io.StringIO()
+
+    async def agen():
+        for i in range(3):
+            await asyncio.sleep(0.003)
+            yield i
+
+    p = Progress(
+        agen(),
+        total=3,
+        desc='Class',
+        stream=stream,
+        refresh_interval=1.0,
+    )
+    async with p:
+        async for _ in p:
+            await asyncio.sleep(0)
+    out = _strip_ansi(stream.getvalue())
+    assert 'Class: 3 it in ' in out
+
+
+# -----------------------------
+# ETA presence only when total is known (heurística simple)
+# -----------------------------
+
+
+@pytest.mark.asyncio
+async def test_eta_only_when_total_known():
+    stream1 = io.StringIO()
+    stream2 = io.StringIO()
+
+    async def agen():
+        for i in range(3):
+            await asyncio.sleep(0.005)
+            yield i
+
+    # Con total -> debería haber "ETA"
+    async for _ in progress(
+        agen(),
+        total=3,
+        desc='HasTotal',
+        stream=stream1,
+        refresh_interval=1.0,
+    ):
+        pass
+
+    # Sin total -> preferimos que no aparezca "ETA" en la salida
+    async for _ in progress(
+        agen(),
+        desc='NoTotal',
+        stream=stream2,
+        refresh_interval=1.0,
+    ):
+        pass
+
+    out1 = stream1.getvalue()
+    out2 = stream2.getvalue()
+    assert 'ETA' in out1
+    assert 'ETA' not in out2