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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.3.0
+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.0 → reactor_runtime-2.3.2}/pyproject.toml

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

{reactor_runtime-2.3.0 → reactor_runtime-2.3.2}/src/reactor_runtime/interface/driver/pipeline_executor.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import inspect
 from typing import Any, Dict, Iterator, List, Optional, Type
 
@@ -144,7 +145,7 @@ class PipelineExecutor(Iterator[StepResult]):
             raise ValueError(f"Unknown event {name!r}. Available events: {available}")
 
         try:
-            entry.event_cls(**kwargs)
+            event = entry.event_cls(**kwargs)
         except TypeError as exc:
             raise TypeError(f"Invalid arguments for event {name!r}: {exc}") from None
 
@@ -155,7 +156,15 @@ class PipelineExecutor(Iterator[StepResult]):
                 if not ok:
                     raise ValueError(f"Validation failed for event {name!r}: {reason}")
 
-        return self._run(self._send_event(entry, **kwargs))
+        # Mirror production dispatch (reactor_model._invoke): splat the
+        # full set of event dataclass fields into the handler kwargs so
+        # callers that omit optional fields get the dataclass default
+        # (e.g. ``None``), not the raw ``FieldInfo`` sentinel that is
+        # still present in the handler function's ``__defaults__``.
+        handler_kwargs = {
+            f.name: getattr(event, f.name) for f in dataclasses.fields(event)
+        }
+        return self._run(self._send_event(entry, **handler_kwargs))
 
     def push_media(self, track_name: str, data: Any) -> None:
         """Push a media frame into an input buffer.

{reactor_runtime-2.3.0 → 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.0 → 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.0 → reactor_runtime-2.3.2}/src/reactor_runtime/profiling/profiler.py

@@ -613,6 +613,18 @@ class ProfilerTimer:
         )
         self._start = None
 
+    def cancel(self) -> None:
+        """Discard the timer run without recording a measurement.
+
+        Safe to call whether or not the timer is currently running. Used to
+        reset state when the caller's scope is aborted before ``.stop()``
+        can fire (e.g. generator exit, session interruption before first
+        output). After ``cancel()``, the timer is idle and ``.start()``
+        will succeed.
+        """
+        self._start = None
+        self.elapsed_ms = None
+
 
 class _NoOpTimer:
     """No-op timer for when profiling is disabled."""
@@ -625,6 +637,9 @@ class _NoOpTimer:
     def stop(self) -> None:
         pass
 
+    def cancel(self) -> None:
+        pass
+
 
 class _NoOpSection:
     """No-op context manager for when profiling is disabled."""

{reactor_runtime-2.3.0 → reactor_runtime-2.3.2}/src/reactor_runtime/runtime_api.py

@@ -41,7 +41,6 @@ logger = get_logger(__name__)
 
 _IDLING_INTERVAL_ENV_VAR = "IDLING_INTERVAL_SECONDS"
 _DEFAULT_IDLING_INTERVAL = 30.0
-_MAX_SESSION_DURATION_ENV_VAR = "MAX_SESSION_DURATION_SECONDS"
 
 
 # ---------------------------------------------------------------------------
@@ -70,10 +69,6 @@ class RuntimeConfig:
     # Priority: ENV > CLI > default. Set to None to use default.
     idling_interval: Optional[float] = None
 
-    # Maximum session duration in seconds. If set, sessions will be automatically
-    # stopped after this duration. Priority: ENV > CLI. Set to None to disable.
-    max_session_duration: Optional[float] = None
-
     profiling_output_dir: Optional[str] = None
 
     def __post_init__(self) -> None:
@@ -102,20 +97,6 @@ class RuntimeConfig:
         if self.idling_interval is None:
             self.idling_interval = _DEFAULT_IDLING_INTERVAL
 
-        # Resolve max_session_duration: ENV > CLI (no default - disabled if not set)
-        max_env = os.getenv(_MAX_SESSION_DURATION_ENV_VAR)
-        if max_env:
-            try:
-                self.max_session_duration = float(max_env)
-            except ValueError:
-                logger.warning(
-                    "Invalid max session duration env value",
-                    env_var=_MAX_SESSION_DURATION_ENV_VAR,
-                    value=max_env,
-                )
-        if self.max_session_duration is not None and self.max_session_duration <= 0:
-            self.max_session_duration = None
-
     @staticmethod
     def parser() -> argparse.ArgumentParser:
         """Return an argument parser for runtime-specific CLI arguments.
@@ -146,12 +127,6 @@ class RuntimeConfig:
             help=f"Idling event interval ({_IDLING_INTERVAL_ENV_VAR} env overrides). "
             f"Default: {_DEFAULT_IDLING_INTERVAL}s",
         )
-        parser.add_argument(
-            "--max-session-duration",
-            type=float,
-            default=None,
-            help=f"Max session seconds ({_MAX_SESSION_DURATION_ENV_VAR} env overrides).",
-        )
         parser.add_argument(
             "--profiling-dir",
             type=str,
@@ -196,9 +171,6 @@ class Runtime(ModelStateMachine, ABC):
         # Idling task - sends periodic IDLING events when in READY state
         self._idling_task: Optional[asyncio.Task] = None
 
-        # Max session duration task - stops session after configured duration
-        self._max_session_duration_task: Optional[asyncio.Task] = None
-
         # Graceful shutdown state (for SIGTERM handling)
         self._shutdown_pending: bool = False
         self._shutdown_event: asyncio.Event = asyncio.Event()
@@ -334,7 +306,6 @@ class Runtime(ModelStateMachine, ABC):
         self._cancel_orphan_timeout()
 
         if previous_state == ModelState.WAITING:
-            self._start_max_session_duration_timeout()
             if self.model is not None:
                 self.model._push_event(Connected())
                 logger.info("Pushed Connected event to model")
@@ -373,7 +344,6 @@ class Runtime(ModelStateMachine, ABC):
         ``@disconnected`` asynchronously on its own thread.
         """
         self._cancel_orphan_timeout()
-        self._cancel_max_session_duration_timeout()
 
         if self.model is not None:
             self.model._push_event(Disconnected())
@@ -805,43 +775,6 @@ class Runtime(ModelStateMachine, ABC):
             self._orphan_task.cancel()
             self._orphan_task = None
 
-    # -----------------------------------------------------------------
-    # Max session duration
-    # -----------------------------------------------------------------
-
-    def _start_max_session_duration_timeout(self) -> None:
-        """Start the max session duration timeout task.
-
-        If max_session_duration is configured, the session will be automatically
-        stopped when the duration expires. This provides a hard limit on session
-        lifetime regardless of client activity.
-        """
-        if (
-            self.config.max_session_duration is None
-            or self.config.max_session_duration <= 0
-        ):
-            return
-        self._cancel_max_session_duration_timeout()
-
-        async def coro() -> None:
-            try:
-                await asyncio.sleep(self.config.max_session_duration)  # type: ignore[arg-type]
-                if self.current_state in (
-                    ModelState.STREAMING,
-                    ModelState.ORPHANED,
-                ):
-                    self.send(ModelEvent.STOP_SESSION)
-            except asyncio.CancelledError:
-                pass
-
-        self._max_session_duration_task = asyncio.create_task(coro())
-
-    def _cancel_max_session_duration_timeout(self) -> None:
-        """Cancel the max session duration timeout if running."""
-        if self._max_session_duration_task is not None:
-            self._max_session_duration_task.cancel()
-            self._max_session_duration_task = None
-
     # -----------------------------------------------------------------
     # Idling
     # -----------------------------------------------------------------

{reactor_runtime-2.3.0 → reactor_runtime-2.3.2}/src/reactor_runtime/runtimes/headless/headless_runtime.py

@@ -397,14 +397,12 @@ async def serve(
             - output_root: Root directory for output (default: "./output")
             - no_ignore_duplicates: If True, write all frames including duplicates (default: False)
             - orphan_timeout: Seconds to wait before stopping orphaned session (default: 30.0)
-            - max_session_duration: Maximum session duration in seconds (default: None, disabled)
     """
     config = HeadlessRuntimeConfig(
         reactor_config=reactor_config,
         output_root=kwargs.get("output_root", "./output"),
         ignore_duplicates=not kwargs.get("no_ignore_duplicates", False),
         orphan_timeout=kwargs.get("orphan_timeout", 30.0),
-        max_session_duration=kwargs.get("max_session_duration"),
         profiling_output_dir=kwargs.get("profiling_output_dir"),
     )
 

{reactor_runtime-2.3.0 → reactor_runtime-2.3.2}/src/reactor_runtime/runtimes/http/http_runtime.py

@@ -647,7 +647,6 @@ async def serve(
             - host: Host to bind to (default: "0.0.0.0")
             - port: Port to bind to (default: 8080)
             - orphan_timeout: Seconds to wait before stopping orphaned session (default: 30.0)
-            - max_session_duration: Maximum session duration in seconds (default: None, disabled)
             - webrtc_port_range: WebRTC ICE UDP port range as tuple (min, max) (default: None)
             - stun_servers: List of STUN server URLs (default: None, uses Google STUN)
             - turn_servers: List of TURN servers in format "username;credential;url" (default: None)
@@ -669,7 +668,6 @@ async def serve(
         host=kwargs.get("host", "0.0.0.0"),
         port=kwargs.get("port", 8080),
         orphan_timeout=kwargs.get("orphan_timeout", 30.0),
-        max_session_duration=kwargs.get("max_session_duration"),
         webrtc_port_range=kwargs.get("webrtc_port_range"),
         stun_servers=kwargs.get("stun_servers"),
         turn_servers=kwargs.get("turn_servers"),

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.0 → 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.0
+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.0 → 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