wavexis 2.2.2__tar.gz → 2.2.4__tar.gz

{wavexis-2.2.2 → wavexis-2.2.4}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to wavexis are documented in this file.
 
+## v2.2.4 — 2026-07-07
+
+### Added
+
+- Progress reporting for long-running operations (`batch`, `multi`, `scrape`)
+- `_progress(current, total, label)` helper shows `[n/total] — label` unless `--quiet`
+
+## v2.2.3 — 2026-07-07
+
+### Added
+
+- Resource cleanup module (`wavexis.cleanup`) with `atexit` and signal handlers
+- Backends are automatically registered for cleanup on crash or signal (SIGINT, SIGTERM, SIGBREAK)
+- Orphaned browser processes are closed even when the process is killed unexpectedly
+
 ## v2.2.2 — 2026-07-07
 
 ### Added

{wavexis-2.2.2 → wavexis-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavexis
-Version: 2.2.2
+Version: 2.2.4
 Summary: Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download
 Project-URL: Homepage, https://github.com/MathiasPaulenko/wavexis
 Project-URL: Repository, https://github.com/MathiasPaulenko/wavexis

{wavexis-2.2.2 → wavexis-2.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wavexis"
-version = "2.2.2"
+version = "2.2.4"
 description = "Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download"
 readme = "README.md"
 license = { text = "MIT" }

wavexis-2.2.4/tests/unit/test_cleanup.py

@@ -0,0 +1,53 @@
+"""Unit tests for resource cleanup module."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+import wavexis.cleanup as cleanup_mod
+from wavexis.cleanup import (
+    _cleanup_sync,
+    register_backend,
+    unregister_backend,
+)
+
+
+@pytest.mark.unit
+class TestCleanup:
+    """Tests for browser cleanup on crash."""
+
+    def setup_method(self) -> None:
+        """Reset cleanup state before each test."""
+        cleanup_mod._cleanup_done = False
+        cleanup_mod._registered_backends.clear()
+
+    def test_register_and_unregister(self) -> None:
+        backend = MagicMock()
+        register_backend(backend)
+        unregister_backend(backend)
+
+    def test_cleanup_with_no_backends(self) -> None:
+        _cleanup_sync()
+
+    def test_cleanup_closes_registered_backends(self) -> None:
+        backend = MagicMock()
+        backend.close = AsyncMock()
+        register_backend(backend)
+        _cleanup_sync()
+        backend.close.assert_called_once()
+
+    def test_cleanup_is_idempotent(self) -> None:
+        backend = MagicMock()
+        backend.close = AsyncMock()
+        register_backend(backend)
+        _cleanup_sync()
+        _cleanup_sync()
+        backend.close.assert_called_once()
+
+    def test_cleanup_swallows_errors(self) -> None:
+        backend = MagicMock()
+        backend.close = AsyncMock(side_effect=RuntimeError("boom"))
+        register_backend(backend)
+        _cleanup_sync()

{wavexis-2.2.2 → wavexis-2.2.4}/wavexis/__init__.py

@@ -1,3 +1,3 @@
 """wavexis — CLI de automatización de navegador."""
 
-__version__ = "2.2.2"
+__version__ = "2.2.4"

wavexis-2.2.4/wavexis/cleanup.py

@@ -0,0 +1,96 @@
+"""Resource cleanup for orphaned browser processes.
+
+Registers atexit and signal handlers to ensure browser backends are closed
+even when the process crashes or is interrupted.
+"""
+
+from __future__ import annotations
+
+import atexit
+import contextlib
+import logging
+import signal
+import sys
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_registered_backends: list[Any] = []
+_cleanup_done = False
+
+_SIGNAL_NAMES: dict[int, str] = {
+    signal.SIGINT: "SIGINT",
+    signal.SIGTERM: "SIGTERM",
+}
+
+with contextlib.suppress(AttributeError):
+    _SIGNAL_NAMES[signal.SIGBREAK] = "SIGBREAK"
+
+
+def register_backend(backend: Any) -> None:
+    """Register a backend for cleanup on exit.
+
+    Args:
+        backend: A backend instance with an async ``close()`` method.
+    """
+    _registered_backends.append(backend)
+
+
+def unregister_backend(backend: Any) -> None:
+    """Unregister a backend after it has been closed normally.
+
+    Args:
+        backend: The backend instance to remove from cleanup tracking.
+    """
+    if backend in _registered_backends:
+        _registered_backends.remove(backend)
+
+
+def _cleanup_sync() -> None:
+    """Synchronously attempt to close all registered backends.
+
+    Uses ``asyncio.run`` if there are backends to close.
+    """
+    global _cleanup_done
+    if _cleanup_done:
+        return
+    _cleanup_done = True
+
+    if not _registered_backends:
+        return
+
+    import asyncio
+
+    async def _close_all() -> None:
+        for backend in _registered_backends:
+            with contextlib.suppress(Exception):
+                await backend.close()
+
+    with contextlib.suppress(Exception):
+        asyncio.run(_close_all())
+
+    _registered_backends.clear()
+
+
+def _signal_handler(signum: int, frame: Any) -> None:
+    """Handle signals by cleaning up and re-raising.
+
+    Args:
+        signum: Signal number received.
+        frame: Current stack frame.
+    """
+    _cleanup_sync()
+    name = _SIGNAL_NAMES.get(signum, str(signum))
+    sys.stderr.write(f"\nwavexis: received {name}, cleaning up…\n")
+    sys.exit(128 + signum)
+
+
+def _setup_signal_handlers() -> None:
+    """Register signal handlers for cleanup."""
+    for sig in _SIGNAL_NAMES:
+        with contextlib.suppress(OSError, ValueError):
+            signal.signal(sig, _signal_handler)
+
+
+atexit.register(_cleanup_sync)
+_setup_signal_handlers()

{wavexis-2.2.2 → wavexis-2.2.4}/wavexis/cli/_capture.py

@@ -18,7 +18,9 @@ from wavexis.actions.screenshot import ScreenshotAction
 from wavexis.cli._shared import (
     Output,
     _browser_options,
+    _echo,
     _get_backend,
+    _progress,
     _run_async,
     _write_json_output,
     app,
@@ -376,17 +378,24 @@ async def _scrape(
 ) -> list[dict[str, Any]]:
     """Async helper for scraping."""
     backend = _get_backend()
+    total = len(urls)
+    _echo(f"Scraping {total} URL(s)…")
     try:
         await backend.launch(_browser_options())
-        params = ScrapeParams(
-            urls=urls,
-            expression=expression,
-            file=file,
-            output_format="json",
-            selector=selector,
-            wait=WaitStrategy(strategy="load"),
-        )
-        return await ScrapeAction(params).execute(backend)
+        results: list[dict[str, Any]] = []
+        for i, url in enumerate(urls):
+            _progress(i + 1, total, url)
+            params = ScrapeParams(
+                urls=[url],
+                expression=expression,
+                file=file,
+                output_format="json",
+                selector=selector,
+                wait=WaitStrategy(strategy="load"),
+            )
+            result = await ScrapeAction(params).execute(backend)
+            results.extend(result)
+        return results
     finally:
         await backend.close()
 

{wavexis-2.2.2 → wavexis-2.2.4}/wavexis/cli/_shared.py

@@ -11,6 +11,7 @@ from typing import Any
 import typer
 
 from wavexis.backend.manager import get_manager
+from wavexis.cleanup import register_backend, unregister_backend
 from wavexis.config import (
     DEVICE_PRESETS,
     BrowserOptions,
@@ -47,10 +48,12 @@ __all__ = [
     "_get_ctx",
     "_handle_error",
     "_load_global_config",
+    "_progress",
     "_run_async",
     "_write_json_output",
     "app",
     "get_manager",
+    "unregister_backend",
 ]
 
 EXIT_SUCCESS = 0
@@ -183,6 +186,21 @@ def _echo(msg: str) -> None:
         typer.echo(msg)
 
 
+def _progress(current: int, total: int, label: str = "") -> None:
+    """Print a progress indicator unless quiet mode is active.
+
+    Args:
+        current: Current item index (1-based).
+        total: Total number of items.
+        label: Optional label to prepend (e.g. URL or action name).
+    """
+    ctx = _get_ctx()
+    if ctx.quiet:
+        return
+    suffix = f" — {label}" if label else ""
+    typer.echo(f"[{current}/{total}]{suffix}")
+
+
 def _handle_error(e: Exception) -> None:
     """Handle a WavexisError with the correct exit code and message.
 
@@ -229,8 +247,13 @@ def _run_async(coro: Any) -> Any:
 
 
 def _get_backend() -> Any:
-    """Select a backend using the preferred backend if set."""
-    return get_manager().select(_get_ctx().preferred_backend)
+    """Select a backend using the preferred backend if set.
+
+    Registers the backend for automatic cleanup on crash or signal.
+    """
+    backend = get_manager().select(_get_ctx().preferred_backend)
+    register_backend(backend)
+    return backend
 
 
 def _browser_options() -> BrowserOptions:

{wavexis-2.2.2 → wavexis-2.2.4}/wavexis/cli/_workflow.py

@@ -19,6 +19,7 @@ from wavexis.cli._shared import (
     _echo,
     _get_backend,
     _handle_error,
+    _progress,
     _run_async,
     app,
 )
@@ -118,10 +119,20 @@ async def _multi(config_path: Any, parallel: bool = False) -> list[Any]:
     from wavexis.multi import execute_actions, parse_yaml
 
     actions = parse_yaml(config_path)
+    total = len(actions)
+    _echo(f"Executing {total} action(s)…")
     backend = _get_backend()
     await backend.launch(_browser_options())
     try:
-        return await execute_actions(actions, backend, parallel=parallel)
+        results: list[Any] = []
+        if parallel:
+            results = await execute_actions(actions, backend, parallel=True)
+        else:
+            for i, action in enumerate(actions):
+                _progress(i + 1, total, str(action))
+                result = await execute_actions([action], backend, parallel=False)
+                results.extend(result)
+        return results
     finally:
         await backend.close()
 
@@ -215,13 +226,22 @@ async def _batch(
         List of results (or exceptions) in the same order as urls.
     """
     semaphore = asyncio.Semaphore(parallel)
+    total = len(urls)
+    completed = 0
+    lock = asyncio.Lock()
 
     async def _run_one(url: str) -> Any:
+        nonlocal completed
         async with semaphore:
             try:
-                return await _batch_single(url, action, out_dir, expression)
+                result = await _batch_single(url, action, out_dir, expression)
+                return result
             except (WavexisError, OSError) as exc:
                 return exc
+            finally:
+                async with lock:
+                    completed += 1
+                    _progress(completed, total, url)
 
     tasks = [_run_one(u) for u in urls]
     return await asyncio.gather(*tasks)