reactor-runtime 2.3.1__tar.gz → 2.3.2__tar.gz

{reactor_runtime-2.3.1 → reactor_runtime-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.3.1
+Version: 2.3.2
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9

{reactor_runtime-2.3.1 → reactor_runtime-2.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.3.1"
+version = "2.3.2"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }

{reactor_runtime-2.3.1 → reactor_runtime-2.3.2}/src/reactor_runtime/interface/model/reactor_model.py

@@ -12,7 +12,8 @@ from __future__ import annotations
 
 import asyncio
 import dataclasses
-from typing import Any, Callable, List, Tuple, Type
+import os
+from typing import Any, Callable, List, Optional, Tuple, Type
 
 from reactor_runtime.interface.events.connected import Connected, Disconnected
 from reactor_runtime.interface.events.event import Event
@@ -96,12 +97,22 @@ class ReactorModel(ReactorCore):
         dispatch_table = build_dispatch_table(handlers)
 
         dispatcher = asyncio.create_task(self._dispatcher(handlers, dispatch_table))
+        crash: Optional[BaseException] = None
         try:
             await self.run()
         except asyncio.CancelledError:
             logger.info("Model cancelled")
-        except Exception:
-            logger.exception("run() crashed")
+        except Exception as exc:
+            # Don't swallow-and-return: log, clean up via finally, then
+            # fail-fast (REA-1740).  ``ReactorPipeline.run()`` contains
+            # its own per-session crashes, so this only fires for custom
+            # ``run()`` overrides.
+            crash = exc
+            logger.exception(
+                "run() crashed — terminating the process",
+                model=type(self).__name__,
+                exc_type=type(exc).__name__,
+            )
         finally:
             dispatcher.cancel()
             try:
@@ -109,6 +120,22 @@ class ReactorModel(ReactorCore):
             except asyncio.CancelledError:
                 pass
 
+        if crash is not None:
+            self._fail_fast(crash)
+
+    def _fail_fast(self, exc: BaseException) -> None:
+        """Terminate the process after an unrecoverable ``run()`` error.
+
+        Uses :func:`os._exit` (not ``sys.exit``) so the whole process
+        goes away regardless of thread.  Override in subclasses or
+        tests.
+        """
+        logger.critical(
+            "Terminating process after unhandled run() exception",
+            exc_type=type(exc).__name__,
+        )
+        os._exit(1)
+
     # ------------------------------------------------------------------
     # run() — override with your generation loop
     # ------------------------------------------------------------------

{reactor_runtime-2.3.1 → reactor_runtime-2.3.2}/src/reactor_runtime/interface/pipeline/reactor_pipeline.py

@@ -241,6 +241,10 @@ class ReactorPipeline(ReactorModel):
                     except BufferClosed:
                         logger.debug("Input buffer closed, ending session")
                         break
+                    # Any other exception propagates up through the outer
+                    # try/finally (gen close + state reset) and out of
+                    # ``run()`` — ``_lifecycle`` then fails-fast via
+                    # ``_fail_fast`` (REA-1740).
 
                     if output is Idle:
                         await asyncio.sleep(0.005)
@@ -251,10 +255,19 @@ class ReactorPipeline(ReactorModel):
                     else:
                         await self.emit(output)
             finally:
-                if is_async:
-                    await gen.aclose()
-                else:
-                    gen.close()
+                # Swallow exceptions from ``gen.close()`` only so a buggy
+                # ``inference()`` ``finally`` cannot mask the original
+                # exception on its way up to ``_lifecycle``.
+                try:
+                    if is_async:
+                        await gen.aclose()
+                    else:
+                        gen.close()
+                except Exception:
+                    logger.exception(
+                        "generator.close() raised during teardown",
+                        model=type(self).__name__,
+                    )
                 self.state = None
                 for buf in self._input_buffers.values():
                     buf.reset()

reactor_runtime-2.3.2/src/reactor_runtime/transports/gstreamer/probes/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+
+from reactor_runtime.transports.gstreamer.probes.fps_probe import FpsProbe
+
+__all__ = ["FpsProbe"]

reactor_runtime-2.3.2/src/reactor_runtime/transports/gstreamer/probes/fps_probe.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+
+"""
+Buffer-count FPS probes on GStreamer pads.
+Each :class:`FpsProbe` instance is independent: attach one probe per pad /
+measurement site (e.g. after ``videoconvert``, after an encoder, on a queue src pad).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Optional
+
+from reactor_runtime.transports.gstreamer.gst import Gst
+from reactor_runtime.utils.log import get_logger
+
+logger = get_logger(__name__)
+
+
+class FpsProbe:
+    """
+    Install a ``Gst.PadProbeType.BUFFER`` probe that reports buffers per second
+    over a rolling wall-clock window (default 1s of monotonic time).
+    Instances do not share state. Typical usage::
+        probe_videoconvert = FpsProbe("video_after_videoconvert")
+        probe_videoconvert.attach(videoconvert.get_static_pad("src"))
+        probe_encoder = FpsProbe("video_after_encoder")
+        probe_encoder.attach(encoder_element.get_static_pad("src"))
+    ``last_fps`` is updated at the end of each completed window. Each completed
+    window is logged at INFO.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        window_ns: Optional[int] = None,
+    ) -> None:
+        self._name = name
+        self._window_ns = int(Gst.SECOND if window_ns is None else window_ns)
+        if self._window_ns <= 0:
+            raise ValueError("window_ns must be positive")
+
+        self._pad: Optional[Gst.Pad] = None
+        self._probe_id: Optional[int] = None
+        self._window_start_ns: Optional[int] = None
+        self._count = 0
+        self._last_fps: Optional[float] = None
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def last_fps(self) -> Optional[float]:
+        """Buffers per second from the last completed ``window_ns`` interval."""
+        return self._last_fps
+
+    def attach(self, pad: Gst.Pad) -> None:
+        """
+        Add this probe on *pad* (usually a src pad, downstream of the element under test).
+        Raises:
+            RuntimeError: if this instance already has a probe installed.
+        """
+        if self._probe_id:
+            raise RuntimeError(
+                f"FpsProbe({self._name!r}) is already attached; call detach() first"
+            )
+        self._pad = pad
+        self._window_start_ns = None
+        self._count = 0
+        self._probe_id = pad.add_probe(
+            Gst.PadProbeType.BUFFER,
+            self._buffer_probe,
+            None,  # user_data (PyGObject passes this as the 3rd callback arg)
+        )
+        if not self._probe_id:
+            self._pad = None
+            raise RuntimeError(f"FpsProbe({self._name!r}): pad.add_probe() failed")
+
+    def detach(self) -> None:
+        """Remove the probe from the pad, if installed."""
+        if self._pad is not None and self._probe_id is not None:
+            self._pad.remove_probe(self._probe_id)
+        self._pad = None
+        self._probe_id = None
+        self._window_start_ns = None
+        self._count = 0
+        self._last_fps = None
+
+    def _buffer_probe(
+        self,
+        _pad: Gst.Pad,
+        info: Gst.PadProbeInfo,
+        _user_data: Any,
+    ) -> Gst.PadProbeReturn:
+        buf = info.get_buffer()
+        if buf is None:
+            return Gst.PadProbeReturn.OK
+
+        now = time.monotonic_ns()
+        window_start = self._window_start_ns
+        if window_start is None:
+            self._window_start_ns = now
+            return Gst.PadProbeReturn.OK
+
+        self._count += 1
+        elapsed = now - window_start
+        if elapsed >= self._window_ns:
+            # buffers / second for the window that just ended
+            fps = self._count * 1_000_000_000 / elapsed
+            self._last_fps = fps
+            logger.info(
+                f"gstreamer_fps_probe name={self._name} fps={fps:.2f} buffers={self._count} window_s={elapsed / 1e9:.3f}",
+            )
+            self._window_start_ns = now
+            self._count = 0
+
+        return Gst.PadProbeReturn.OK

{reactor_runtime-2.3.1 → reactor_runtime-2.3.2}/src/reactor_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.3.1
+Version: 2.3.2
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9

{reactor_runtime-2.3.1 → reactor_runtime-2.3.2}/src/reactor_runtime.egg-info/SOURCES.txt

@@ -101,6 +101,8 @@ src/reactor_runtime/transports/gstreamer/encoders/h265.py
 src/reactor_runtime/transports/gstreamer/encoders/opus.py
 src/reactor_runtime/transports/gstreamer/encoders/vp8.py
 src/reactor_runtime/transports/gstreamer/encoders/vp9.py
+src/reactor_runtime/transports/gstreamer/probes/__init__.py
+src/reactor_runtime/transports/gstreamer/probes/fps_probe.py
 src/reactor_runtime/transports/gstreamer/receiver/__init__.py
 src/reactor_runtime/transports/gstreamer/receiver/audio.py
 src/reactor_runtime/transports/gstreamer/receiver/base.py