reactor-runtime 2.0.0__tar.gz → 2.0.2__tar.gz

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/PKG-INFO

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

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/pyproject.toml

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

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_cli/commands/init.py

@@ -6,6 +6,7 @@ import importlib.resources
 
 
 _TEMPLATE_FILES = {
+    "pipeline.py": "pipeline.py",
     "model.py": "model.py",
     "reactor.yaml": "reactor.yaml",
     "config.yml": "config.yml",
@@ -85,4 +86,5 @@ class InitCommand:
 
         print(f"\nReactor workspace '{model_name}' created.")
         print(f"\n  cd {model_name}")
+        print("  pip install -r requirements.txt")
         print("  reactor run\n")

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_cli/commands/run.py

@@ -12,7 +12,6 @@ from reactor_cli.utils.config import (
     _valid_port,
 )
 from reactor_cli.utils.runtime import load_runtime
-from reactor_runtime import __version__
 from reactor_runtime.config import ReactorConfig
 from reactor_runtime.transports.config import (
     GSTREAMER_INSTALL_URL,
@@ -207,14 +206,13 @@ class RunCommand:
         _RESET = "\033[0m"
         if runtime_kwargs.get("transport_type") is None:
             runtime_kwargs["transport_type"] = resolve_default_transport()
-            print(
-                f"{_ORANGE}Transport: "
-                f"{runtime_kwargs['transport_type'].name.lower()} "
-                f"(auto-detected){_RESET}"
-            )
         else:
             try:
                 validate_transport_available(runtime_kwargs["transport_type"])
+                print(
+                    f"{_ORANGE}Transport: "
+                    f"{runtime_kwargs['transport_type'].name.lower()}{_RESET}"
+                )
             except ImportError as exc:
                 name = runtime_kwargs["transport_type"].name.lower()
                 print(
@@ -244,9 +242,7 @@ class RunCommand:
         # Run
         # ---------------------------------------------------------
         log_level = "DEBUG" if self.args.verbose else "INFO"
-
-        print(f"Starting reactor runtime v{__version__} ({runtime_name})")
-        print(f"Model: {reactor_config.name} ({reactor_config.model})")
+        detailed_logs = runtime_kwargs.pop("detailed_logs", False)
 
         try:
             run_reactor_runtime(
@@ -254,6 +250,7 @@ class RunCommand:
                 reactor_config=reactor_config,
                 model_root=str(model_path),
                 log_level=log_level,
+                show_timestamps=detailed_logs,
                 **runtime_kwargs,
             )
         except KeyboardInterrupt:

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime/runtime_api.py

@@ -124,6 +124,13 @@ class RuntimeConfig:
             argparse.ArgumentParser with runtime-specific arguments
         """
         parser = argparse.ArgumentParser(add_help=False)
+        parser.add_argument(
+            "--detailed-logs",
+            action=argparse.BooleanOptionalAction,
+            default=False,
+            dest="detailed_logs",
+            help="Show timestamps and full log detail. Default: off.",
+        )
         parser.add_argument(
             "--orphan-timeout",
             type=float,
@@ -236,7 +243,7 @@ class Runtime(ModelStateMachine, ABC):
         )
         self.model_thread.start()
 
-        logger.info(
+        logger.debug(
             "Model loaded, emission started, run() thread spawned",
             model=self.config.reactor_config.model,
         )

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime/runtimes/http/http_runtime.py

@@ -22,6 +22,7 @@ Other:
 """
 
 import asyncio
+import os
 from typing import Optional
 import numpy as np
 from fastapi import FastAPI, HTTPException
@@ -510,6 +511,16 @@ class HttpRuntime(Runtime):
         if self._server is not None:
             self._server.should_exit = True
 
+    # -----------------------------------------------------------------
+    # State hooks
+    # -----------------------------------------------------------------
+
+    def on_before_initialization_success(self, **kwargs) -> None:
+        aqua, reset = "\033[96m", "\033[0m"
+        url = f"http://{self.config.host}:{self.config.port}"
+        logger.info("Started runtime process", pid=os.getpid())
+        logger.info(f"Reactor runtime running on {aqua}{url}{reset}")
+
     # -----------------------------------------------------------------
     # run()
     # -----------------------------------------------------------------
@@ -522,7 +533,8 @@ class HttpRuntime(Runtime):
             app=self.app,
             host=self.config.host,
             port=self.config.port,
-            log_level="info",
+            log_level="warning",
+            access_log=False,
         )
         self._server = uvicorn.Server(uvicorn_config)
 

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime/transports/config.py

@@ -254,25 +254,16 @@ def resolve_default_transport() -> TransportType:
     """Determine the best available transport when none is explicitly specified.
 
     Tries GStreamer first (by importing the gst helper module which initializes
-    GStreamer), falling back to aiortc with an error message if anything goes wrong.
+    GStreamer), falling back silently to aiortc if anything goes wrong.
     """
 
     try:
         from reactor_runtime.transports.gstreamer.gst import Gst  # noqa: F401
-    except Exception as e:
-        print(
-            f"{_ORANGE}GStreamer failed to initialize, falling back to aiortc. Error: {e}{_RESET}"
-        )
+    except Exception:
         return TransportType.AIORTC
 
     missing = _check_gstreamer_elements()
     if missing:
-        formatted = ", ".join(missing)
-        print(
-            f"{_ORANGE}GStreamer is missing required elements: {formatted}\n"
-            f"Falling back to aiortc. "
-            f"Install the missing plugins: {GSTREAMER_INSTALL_URL}{_RESET}"
-        )
         return TransportType.AIORTC
 
     return TransportType.GSTREAMER

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime/transports/gstreamer/decoders/h264.py

@@ -92,7 +92,6 @@ class H264DecoderBin(BaseRTPDecoderBin):
 
             1) NVIDIA hardware decoders (GPU accelerated)
             2) avdec_h264 (libav software decoder)
-            3) openh264dec (generic fallback)
 
         Hardware decoder names vary depending on:
             - Distribution
@@ -121,15 +120,6 @@ class H264DecoderBin(BaseRTPDecoderBin):
             )
             return "avdec_h264"
 
-        # ---------------------------------------------------------
-        # Generic fallback (if present in build)
-        # ---------------------------------------------------------
-        if Gst.ElementFactory.find("openh264dec") is not None:
-            logger.info(
-                "H264DecoderBin: using software (SW) decoder: openh264dec",
-            )
-            return "openh264dec"
-
         raise RuntimeError(
-            "No H264 decoder available (tried: nvh264dec, nvdec_h264, nvv4l2decoder, avdec_h264, openh264dec)"
+            "No H264 decoder available (tried: nvh264dec, nvdec_h264, nvv4l2decoder, avdec_h264)"
         )

reactor_runtime-2.0.2/src/reactor_runtime/utils/launch.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""Entry point for running the Reactor runtime."""
+
+import asyncio
+import logging
+import os
+import sys
+from typing import Callable, List, Optional
+
+from reactor_runtime import __version__
+from reactor_runtime.config import ReactorConfig
+from reactor_runtime.utils.log import (
+    LOG_DATEFMT,
+    LOG_FORMAT,
+    LOG_FORMAT_BRIEF,
+    ColorFormatter,
+    get_logger,
+)
+
+logger = get_logger(__name__)
+
+
+def add_import_paths(paths: List[str]) -> None:
+    """Prepend provided directories to sys.path if they exist."""
+    for p in paths:
+        if not p:
+            continue
+        ap = os.path.abspath(p)
+        if os.path.isdir(ap) and ap not in sys.path:
+            sys.path.insert(0, ap)
+
+
+def configure_logging(level: str, show_timestamps: bool = True) -> None:
+    fmt = LOG_FORMAT if show_timestamps else LOG_FORMAT_BRIEF
+    handler = logging.StreamHandler()
+    handler.setFormatter(ColorFormatter(fmt, datefmt=LOG_DATEFMT))
+    logging.root.addHandler(handler)
+    logging.root.setLevel(getattr(logging, level.upper(), logging.INFO))
+    logging.getLogger("aiortc").setLevel(logging.WARNING)
+    logging.getLogger("av").setLevel(logging.WARNING)
+    logging.getLogger("aioice").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.error").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+
+def _infer_runtime_name(serve_fn: Callable) -> str:
+    """Derive a short runtime label from the serve function's module path.
+
+    e.g. ``reactor_runtime.runtimes.http.http_runtime`` -> ``http``
+         ``reactor_runtime.runtimes._redis._redis_runtime`` -> ``redis``
+    """
+    parts = getattr(serve_fn, "__module__", "").split(".")
+    if len(parts) >= 3:
+        return parts[2].lstrip("_")
+    return "unknown"
+
+
+def run_reactor_runtime(
+    runtime_serve_fn: Callable,
+    reactor_config: ReactorConfig,
+    model_root: Optional[str] = None,
+    log_level: str = "INFO",
+    show_timestamps: bool = True,
+    **runtime_kwargs,
+) -> None:
+    """Run the Reactor runtime.
+
+    Args:
+        runtime_serve_fn: The ``serve()`` function from the runtime module.
+        reactor_config: Parsed ``reactor.yaml`` (with ``config`` resolved
+            to an absolute path and ``config_overrides`` populated).
+        model_root: Directory to add to sys.path for model imports.
+        log_level: Logging level.
+        show_timestamps: Include timestamps in log output (disabled for local
+            HTTP runtime where output is watched interactively).
+        **runtime_kwargs: Runtime-specific arguments passed to serve().
+    """
+    configure_logging(log_level, show_timestamps=show_timestamps)
+
+    runtime_name = _infer_runtime_name(runtime_serve_fn)
+    logger.info(
+        "Starting reactor runtime",
+        version=__version__,
+        runtime=runtime_name,
+    )
+    model_kw: dict = {
+        "name": reactor_config.name,
+        "entrypoint": reactor_config.model,
+    }
+    if reactor_config.config:
+        model_kw["config"] = reactor_config.config
+    logger.info("Model detected", **model_kw)
+
+    if model_root is not None:
+        add_import_paths([model_root])
+
+    asyncio.run(
+        runtime_serve_fn(
+            reactor_config=reactor_config,
+            **runtime_kwargs,
+        )
+    )

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime/utils/log.py

@@ -20,13 +20,46 @@ from typing import Any, Optional
 session_id_var: ContextVar[Optional[str]] = ContextVar("session_id", default=None)
 
 
-# Shared log format / date-format used across the runtime.
-LOG_FORMAT = "%(asctime)s %(levelname)-8s %(name)s: %(message)s"
+LOG_FORMAT = "%(asctime)s %(levelname)s %(name)s: %(message)s"
+LOG_FORMAT_BRIEF = "%(levelname)s %(message)s"
 LOG_DATEFMT = "%Y-%m-%dT%H:%M:%S%z"
 
-# Keep underscore-prefixed aliases so existing imports don't break.
-_LOG_FORMAT = LOG_FORMAT
-_LOG_DATEFMT = LOG_DATEFMT
+_RESET = "\033[0m"
+
+_LEVEL_COLORS: dict[int, str] = {
+    logging.DEBUG: "\033[37m",  # gray
+    logging.INFO: "\033[32m",  # green
+    logging.WARNING: "\033[33m",  # yellow
+    logging.ERROR: "\033[31m",  # red
+    logging.CRITICAL: "\033[1;31m",  # bold red
+}
+
+
+_RUNTIME_PREFIXES = ("reactor_runtime.", "reactor_cli.")
+_MODEL_COLOR = "\033[36m"
+
+
+class ColorFormatter(logging.Formatter):
+    """Formatter that colorizes log levels and tags model logs."""
+
+    _COL = 12  # visual width: fits "CRITICAL MDL"
+
+    def format(self, record: logging.LogRecord) -> str:
+        orig = record.levelname
+        color = _LEVEL_COLORS.get(record.levelno, "")
+
+        if record.name.startswith(_RUNTIME_PREFIXES):
+            pad = self._COL - len(orig)
+            record.levelname = f"{color}{orig}{_RESET}{' ' * pad}"
+        else:
+            pad = self._COL - len(orig) - 4  # 4 = len(" MDL")
+            record.levelname = (
+                f"{color}{orig}{_RESET} {_MODEL_COLOR}MDL{_RESET}{' ' * max(pad, 0)}"
+            )
+
+        result = super().format(record)
+        record.levelname = orig
+        return result
 
 
 class StructuredLogger:
@@ -39,15 +72,18 @@ class StructuredLogger:
 
     # -- internal helpers --------------------------------------------------
 
+    _BLUE = "\033[38;5;25m"
+    _RESET = "\033[0m"
+
     @staticmethod
     def _fmt(msg: str, kw: dict[str, Any]) -> str:
-        # Auto-inject session_id from ContextVar if not explicitly provided.
         sid = session_id_var.get()
         if sid and "session_id" not in kw:
             kw["session_id"] = sid
         if not kw:
             return msg
-        pairs = " ".join(f"{k}={v}" for k, v in kw.items())
+        b, r = StructuredLogger._BLUE, StructuredLogger._RESET
+        pairs = " ".join(f"{b}{k}={r}{v}" for k, v in kw.items())
         return f"{msg} {pairs}"
 
     # -- public API --------------------------------------------------------

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime.egg-info/PKG-INFO

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

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/reactor_runtime.egg-info/SOURCES.txt

@@ -117,5 +117,6 @@ src/template/README.md
 src/template/__init__.py
 src/template/config.yml
 src/template/model.py
+src/template/pipeline.py
 src/template/reactor.yaml
 src/template/requirements.txt

reactor_runtime-2.0.2/src/template/README.md

@@ -0,0 +1,45 @@
+# My Reactor Model
+
+A real-time video model built with Reactor Runtime.
+
+## Setup and run
+
+```bash
+pip install -r requirements.txt
+reactor run
+```
+
+This starts the model locally. Connect with a WebRTC client at the URL printed by the runtime.
+
+## Project structure
+
+| File | Purpose |
+|------|---------|
+| `pipeline.py` | **ReactorPipeline** — generator pattern with auto state management (default) |
+| `model.py` | **ReactorModel** — manual run loop with explicit events and lifecycle |
+| `reactor.yaml` | Tells the runtime where to find your model class |
+| `config.yml` | Model configuration (passed to `load()` as a dict) |
+| `requirements.txt` | Extra Python dependencies |
+
+## How it works
+
+- **`MyOutput`** declares the video track the model sends to clients.
+- **`MyState`** declares parameters clients can change in real-time. Each field auto-generates a `set_<field>` event — no handler code needed.
+- **`inference()`** is a generator that yields frames in batches. Read `self.state` to pick up the latest client values.
+- **`load()`** runs once at startup — put weight loading here.
+
+## Switching to the ReactorModel version
+
+Edit `reactor.yaml` and change the model entry:
+
+```yaml
+model: model:MyModel
+```
+
+Then run again. The ReactorModel version gives you full control over the run loop, events, and session lifecycle.
+
+## Next steps
+
+- Add `Input` tracks to receive webcam video from the client
+- Add `@event` handlers for custom logic (e.g. encoding a prompt)
+- Add `ModelMessage` subclasses to send structured data back to the client

reactor_runtime-2.0.2/src/template/config.yml

@@ -0,0 +1,3 @@
+width: 640
+height: 480
+chunk_size: 4

reactor_runtime-2.0.2/src/template/model.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""
+My first Reactor model — ReactorModel version.
+
+Same model as pipeline.py, but using the lower-level ReactorModel base
+class where you manage the run loop, events, and session lifecycle
+explicitly.
+
+Run with:  reactor run  (after updating reactor.yaml to point here)
+"""
+
+from typing import Any
+
+
+from reactor_runtime.interface import (
+    InputField,
+    ReactorModel,
+    connected,
+    disconnected,
+    event,
+)
+
+from pipeline import MyOutput, render_batch
+
+
+# -- Model ---------------------------------------------------------------------
+
+
+class MyModel(ReactorModel):
+    fps = 30
+    buffer_size = 8
+
+    def load(self, config: dict[str, Any]) -> None:
+        self.width = config.get("width", 640)
+        self.height = config.get("height", 480)
+        self.chunk_size = config.get("chunk_size", 4)
+        self.brightness = 1.0
+
+    @connected
+    def on_connect(self):
+        self.brightness = 1.0
+
+    @disconnected
+    def on_disconnect(self):
+        self.output_buffer.flush()
+
+    @event(name="set_brightness", description="Brightness multiplier")
+    def set_brightness(
+        self,
+        brightness: float = InputField(default=1.0, ge=0.0, le=2.0),
+    ):
+        self.brightness = brightness
+
+    async def run(self) -> None:
+        while True:
+            await self.connected.wait()
+            frame_idx = 0
+
+            while self.connected.is_set():
+                # Sync work is fine here — events dispatch at await points
+                batch, frame_idx = render_batch(
+                    self.width,
+                    self.height,
+                    self.chunk_size,
+                    frame_idx,
+                    self.brightness,
+                )
+                await self.emit(MyOutput(main_video=batch))

reactor_runtime-2.0.2/src/template/pipeline.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""
+My first Reactor model — ReactorPipeline version.
+
+Generates animated gradient frames with a client-controllable brightness
+multiplier. Frames are produced in configurable chunks to demonstrate
+batch yielding.
+
+Run with:  reactor run
+"""
+
+from dataclasses import dataclass
+from typing import Any
+import time
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+from reactor_runtime.interface import (
+    InputField,
+    InputState,
+    Output,
+    ReactorPipeline,
+    Video,
+)
+
+
+# -- Tracks --------------------------------------------------------------------
+
+
+@dataclass
+class MyOutput(Output):
+    main_video: Video
+
+
+# -- State ---------------------------------------------------------------------
+
+
+@dataclass
+class MyState(InputState):
+    brightness: float = InputField(
+        default=1.0, ge=0.0, le=2.0, description="Brightness multiplier"
+    )
+
+
+# -- Model ---------------------------------------------------------------------
+
+
+class MyModel(ReactorPipeline):
+    state: MyState
+    buffer_size = 8
+
+    def load(self, config: dict[str, Any]) -> None:
+        self.width = config.get("width", 640)
+        self.height = config.get("height", 480)
+        self.chunk_size = config.get("chunk_size", 4)
+
+    def inference(self):
+        frame_idx = 0
+        while True:
+            batch, frame_idx = render_batch(
+                self.width,
+                self.height,
+                self.chunk_size,
+                frame_idx,
+                self.state.brightness,
+            )
+            yield MyOutput(main_video=batch)
+
+
+# -- Rendering -----------------------------------------------------------------
+
+
+_FRAME_BUDGET = 1 / 30
+
+
+def render_batch(
+    width: int,
+    height: int,
+    chunk_size: int,
+    start_idx: int,
+    brightness: float,
+) -> tuple[np.ndarray, int]:
+    """Generate a batch of animated gradient frames with brightness applied.
+
+    Returns the batch as ``(N, H, W, 3)`` uint8 and the next frame index.
+    """
+    frames = []
+    for i in range(chunk_size):
+        idx = start_idx + i
+        t0 = time.perf_counter()
+
+        img = np.zeros((height, width, 3), dtype=np.float32)
+        ys = np.linspace(0, 1, height, dtype=np.float32)[:, None]
+        img[:, :, 0] = ys * 128
+        img[:, :, 2] = (1 - ys) * 128
+
+        bar_x = (idx * 4) % width
+        bar_w = max(1, width // 20)
+        img[:, bar_x : min(width, bar_x + bar_w), 1] = 128
+
+        img = np.clip(img * brightness, 0, 255).astype(np.uint8)
+        img = draw_text(img, f"Frame {idx}  |  Brightness {brightness:.1f}")
+        frames.append(img)
+
+        remaining = _FRAME_BUDGET - (time.perf_counter() - t0)
+        if remaining > 0:
+            time.sleep(remaining)
+
+    return np.stack(frames), start_idx + chunk_size
+
+
+def draw_text(
+    frame: np.ndarray,
+    text: str,
+    position: tuple = (16, 30),
+) -> np.ndarray:
+    """Draw white text with a dark outline onto a frame."""
+    img = Image.fromarray(frame)
+    draw = ImageDraw.Draw(img)
+    x, y = position
+    for dx, dy in [(-1, -1), (-1, 1), (1, -1), (1, 1)]:
+        draw.text((x + dx, y + dy), text, fill=(0, 0, 0))
+    draw.text((x, y), text, fill=(255, 255, 255))
+    return np.array(img)

{reactor_runtime-2.0.0 → reactor_runtime-2.0.2}/src/template/reactor.yaml

@@ -1,4 +1,4 @@
 # Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
-model: model:MyModel
+model: pipeline:MyModel
 name: my-model
-config: config.yml
+config: config.yml

reactor_runtime-2.0.2/src/template/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+Pillow