apte 0.3.0__tar.gz → 0.3.2__tar.gz

{apte-0.3.0 → apte-0.3.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: apte
-Version: 0.3.0
-Summary: Async-first Python testing framework
+Version: 0.3.2
+Summary: Async-first Python testing framework with explicit dependency injection and native LLM evals
 Author-email: Renaud Cepre <renaudcepre@protonmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/renaudcepre/apte
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://renaudcepre.github.io/apte/
 Project-URL: Repository, https://github.com/renaudcepre/apte
 Project-URL: Changelog, https://github.com/renaudcepre/apte/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/renaudcepre/apte/issues
-Keywords: testing,async,dependency-injection,test-framework,asyncio,fixtures
+Keywords: testing,async,dependency-injection,test-framework,asyncio,fixtures,llm-evals,llm-evaluation,evals,pytest-alternative
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -22,7 +22,7 @@ Classifier: Framework :: AsyncIO
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: typing-extensions>=4.16.0
 Provides-Extra: rich
 Requires-Dist: rich>=15.0.0; extra == "rich"
 Provides-Extra: web
@@ -41,6 +41,8 @@ An eval is just a test that returns a value - scored, not asserted. Your evals g
 real fixtures, dependency injection and parallelism, and live right next to the
 tests they ship with. Python 3.10+, installs lean (Rich UI optional).
 
+![Apte demo: tests and evals in one framework](assets/demo.gif)
+
 ---
 
 ## Why Apte?
@@ -149,14 +151,12 @@ apte run test_sample:session
 
 ## Installation
 
-Apte is not yet on PyPI. Install directly from GitHub:
-
 ```bash
 # With uv (recommended)
-uv add git+https://github.com/renaudcepre/apte.git
+uv add apte
 
 # With pip
-pip install git+https://github.com/renaudcepre/apte.git
+pip install apte
 ```
 
 ## CLI

{apte-0.3.0 → apte-0.3.2}/README.md

@@ -10,6 +10,8 @@ An eval is just a test that returns a value - scored, not asserted. Your evals g
 real fixtures, dependency injection and parallelism, and live right next to the
 tests they ship with. Python 3.10+, installs lean (Rich UI optional).
 
+![Apte demo: tests and evals in one framework](assets/demo.gif)
+
 ---
 
 ## Why Apte?
@@ -118,14 +120,12 @@ apte run test_sample:session
 
 ## Installation
 
-Apte is not yet on PyPI. Install directly from GitHub:
-
 ```bash
 # With uv (recommended)
-uv add git+https://github.com/renaudcepre/apte.git
+uv add apte
 
 # With pip
-pip install git+https://github.com/renaudcepre/apte.git
+pip install apte
 ```
 
 ## CLI

{apte-0.3.0 → apte-0.3.2}/apte/__init__.py

@@ -14,7 +14,7 @@ from apte.loader import LoadError, load_session
 from apte.plugin import PluginBase
 from apte.shell import CommandResult, Shell
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 __all__ = [
     "ApteError",

{apte-0.3.0 → apte-0.3.2}/apte/core/execution/parallel.py

@@ -175,8 +175,16 @@ class ParallelExecutor:
                 ctx.queue.task_done()
 
     def _should_stop(self, exitfirst_flag: asyncio.Event | None) -> bool:
-        """Check if execution should stop (interrupt or exitfirst)."""
-        return self._interrupt_handler.soft_stop_event.is_set() or (
+        """Check if execution should stop (interrupt or exitfirst).
+
+        Reads the synchronous interrupt state, not soft_stop_event: the event is
+        armed via call_soon_threadsafe (one loop iteration late), but _state is
+        set the instant the signal handler runs. Between two tests the scheduler
+        can reach this check without yielding to the loop (sync handlers run
+        inline, so emit() never suspends), so the event may still be unset while
+        a stop is already pending.
+        """
+        return self._interrupt_handler.should_stop_new_tests or (
             exitfirst_flag is not None and exitfirst_flag.is_set()
         )
 

{apte-0.3.0 → apte-0.3.2}/apte/events/bus.py

@@ -26,12 +26,22 @@ class _RegisteredHandler:
 
     func: Callable[..., Any]
     name: str
+    blocking: bool = False
+    # Computed once at registration: a handler's async-ness never changes, and
+    # asyncio.iscoroutinefunction is costly (unwraps partials, inspects flags).
+    is_async: bool = False
 
 
 class EventBus:
     """Decoupled event dispatch with async support.
 
-    Sync handlers are executed in a thread pool (blocking the event emission).
+    Sync handlers run inline on the event loop by default: they are expected to
+    be fast and non-blocking (reporters buffering, result collection). Inline
+    dispatch avoids a thread-pool round-trip (socket + loop wakeup) per call,
+    which otherwise dominates the per-test cost. Handlers that genuinely block
+    (heavy disk/network work) opt in with `on(..., blocking=True)` to be
+    offloaded to the thread pool instead.
+
     Async handlers run fire-and-forget and are tracked for cleanup.
 
     Use wait_pending() before session end to ensure all async handlers complete.
@@ -84,10 +94,24 @@ class EventBus:
                 else:
                     handler()
 
-    def on(self, event: Event, handler: Callable[..., Any]) -> None:
-        """Register a handler for an event."""
+    def on(
+        self, event: Event, handler: Callable[..., Any], *, blocking: bool = False
+    ) -> None:
+        """Register a handler for an event.
+
+        Sync handlers run inline by default. Pass `blocking=True` for sync
+        handlers that perform heavy blocking work and must not stall the loop;
+        those are offloaded to the thread pool.
+        """
         name = get_callable_name(handler)
-        self._handlers[event].append(_RegisteredHandler(func=handler, name=name))
+        self._handlers[event].append(
+            _RegisteredHandler(
+                func=handler,
+                name=name,
+                blocking=blocking,
+                is_async=asyncio.iscoroutinefunction(handler),
+            )
+        )
 
     def off(self, event: Event, handler: Callable[..., Any]) -> None:
         """Unregister a handler for an event."""
@@ -105,7 +129,7 @@ class EventBus:
         for handler_entry in self._handlers[event]:
             handler = handler_entry.func
             handler_name = handler_entry.name
-            is_async = asyncio.iscoroutinefunction(handler)
+            is_async = handler_entry.is_async
 
             await self._emit_handler_start(handler_name, event, is_async)
             start_time = time.perf_counter()
@@ -119,16 +143,21 @@ class EventBus:
                     )
                     self._pending_tasks.add(task)
                     task.add_done_callback(self._pending_tasks.discard)
-                else:
+                elif handler_entry.blocking:
+                    # Opt-in: offload genuinely blocking handlers to a thread,
+                    # serialized per owner to protect shared instance state.
                     lock = self._get_owner_lock(handler)
-                    if data is not None:
-                        await run_in_threadpool(
-                            self._run_sync_with_lock, lock, handler, data
-                        )
-                    else:
-                        await run_in_threadpool(
-                            self._run_sync_with_lock, lock, handler, None
-                        )
+                    await run_in_threadpool(
+                        self._run_sync_with_lock, lock, handler, data
+                    )
+                    duration = time.perf_counter() - start_time
+                    await self._emit_handler_end(
+                        handler_name, event, False, duration, None
+                    )
+                else:
+                    # Default: run inline. No thread, so no cross-thread race and
+                    # no lock needed; the call runs to completion on the loop.
+                    self._run_sync_with_lock(None, handler, data)
                     duration = time.perf_counter() - start_time
                     await self._emit_handler_end(
                         handler_name, event, False, duration, None
@@ -170,13 +199,16 @@ class EventBus:
         self, name: str, event: Event, is_async: bool
     ) -> None:
         """Emit HANDLER_START without triggering handler events (avoid recursion)."""
+        listeners = self._handlers[Event.HANDLER_START]
+        if not listeners:
+            return
         info = HandlerInfo(name=name, event=event, is_async=is_async)
-        for handler_entry in self._handlers[Event.HANDLER_START]:
+        for handler_entry in listeners:
             try:
-                if asyncio.iscoroutinefunction(handler_entry.func):
+                if handler_entry.is_async:
                     await handler_entry.func(info)
                 else:
-                    await run_in_threadpool(handler_entry.func, info)
+                    handler_entry.func(info)
             except Exception:
                 logger.exception("HANDLER_START listener %s failed", handler_entry.name)
 
@@ -189,15 +221,18 @@ class EventBus:
         error: Exception | None,
     ) -> None:
         """Emit HANDLER_END without triggering handler events (avoid recursion)."""
+        listeners = self._handlers[Event.HANDLER_END]
+        if not listeners:
+            return
         info = HandlerInfo(
             name=name, event=event, is_async=is_async, duration=duration, error=error
         )
-        for handler_entry in self._handlers[Event.HANDLER_END]:
+        for handler_entry in listeners:
             try:
-                if asyncio.iscoroutinefunction(handler_entry.func):
+                if handler_entry.is_async:
                     await handler_entry.func(info)
                 else:
-                    await run_in_threadpool(handler_entry.func, info)
+                    handler_entry.func(info)
             except Exception:
                 logger.exception("HANDLER_END listener %s failed", handler_entry.name)
 
@@ -216,10 +251,10 @@ class EventBus:
         for handler_entry in self._handlers[event]:
             handler = handler_entry.func
             try:
-                if asyncio.iscoroutinefunction(handler):
+                if handler_entry.is_async:
                     result = await handler(data)
                 else:
-                    result = await run_in_threadpool(handler, data)
+                    result = handler(data)
                 if result is not None:
                     data = result
             except Exception:

{apte-0.3.0 → apte-0.3.2}/apte.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: apte
-Version: 0.3.0
-Summary: Async-first Python testing framework
+Version: 0.3.2
+Summary: Async-first Python testing framework with explicit dependency injection and native LLM evals
 Author-email: Renaud Cepre <renaudcepre@protonmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/renaudcepre/apte
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://renaudcepre.github.io/apte/
 Project-URL: Repository, https://github.com/renaudcepre/apte
 Project-URL: Changelog, https://github.com/renaudcepre/apte/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/renaudcepre/apte/issues
-Keywords: testing,async,dependency-injection,test-framework,asyncio,fixtures
+Keywords: testing,async,dependency-injection,test-framework,asyncio,fixtures,llm-evals,llm-evaluation,evals,pytest-alternative
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -22,7 +22,7 @@ Classifier: Framework :: AsyncIO
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: typing-extensions>=4.16.0
 Provides-Extra: rich
 Requires-Dist: rich>=15.0.0; extra == "rich"
 Provides-Extra: web
@@ -41,6 +41,8 @@ An eval is just a test that returns a value - scored, not asserted. Your evals g
 real fixtures, dependency injection and parallelism, and live right next to the
 tests they ship with. Python 3.10+, installs lean (Rich UI optional).
 
+![Apte demo: tests and evals in one framework](assets/demo.gif)
+
 ---
 
 ## Why Apte?
@@ -149,14 +151,12 @@ apte run test_sample:session
 
 ## Installation
 
-Apte is not yet on PyPI. Install directly from GitHub:
-
 ```bash
 # With uv (recommended)
-uv add git+https://github.com/renaudcepre/apte.git
+uv add apte
 
 # With pip
-pip install git+https://github.com/renaudcepre/apte.git
+pip install apte
 ```
 
 ## CLI

{apte-0.3.0 → apte-0.3.2}/apte.egg-info/requires.txt

@@ -1,4 +1,4 @@
-typing-extensions>=4.15.0
+typing-extensions>=4.16.0
 
 [rich]
 rich>=15.0.0

{apte-0.3.0 → apte-0.3.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apte"
-version = "0.3.0"
-description = "Async-first Python testing framework"
+version = "0.3.2"
+description = "Async-first Python testing framework with explicit dependency injection and native LLM evals"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
@@ -19,6 +19,10 @@ keywords = [
     "test-framework",
     "asyncio",
     "fixtures",
+    "llm-evals",
+    "llm-evaluation",
+    "evals",
+    "pytest-alternative",
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -32,7 +36,7 @@ classifiers = [
     "Framework :: AsyncIO",
 ]
 dependencies = [
-    "typing-extensions>=4.15.0",
+    "typing-extensions>=4.16.0",
 ]
 
 [project.urls]
@@ -56,6 +60,11 @@ output-format = "concise"
 line-length = 88
 extend-exclude = []
 
+[tool.ruff.format]
+# ruff >= 0.16 formats Python code blocks inside Markdown by default and
+# inserts PEP 8 blank lines in every doc snippet. Docs stay hand-formatted.
+exclude = ["*.md"]
+
 [tool.ruff.lint]
 select = [
     "F", # Pyflakes