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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.0.2
+Version: 2.2.0
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9
@@ -12,6 +12,7 @@ Requires-Dist: av>=14.0.0
 Requires-Dist: aiortc>=1.14.0
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn[standard]>=0.23.0
+Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: redis
 Requires-Dist: opentelemetry-api~=1.39
 Requires-Dist: opentelemetry-sdk~=1.39

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.0.2"
+version = "2.2.0"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }
@@ -20,6 +20,7 @@ dependencies = [
     "aiortc>=1.14.0",
     "fastapi>=0.100.0",
     "uvicorn[standard]>=0.23.0",
+	"aiohttp>=3.9.0",
 	"redis",
 	"opentelemetry-api~=1.39",
 	"opentelemetry-sdk~=1.39",
@@ -45,4 +46,4 @@ template = ["*.yaml", "*.yml", "*.txt", "*.md"]
 # Proto dependency from reactor-team/reactor-proto
 # Release tag format: golang/v{version}
 # Wheel name format: reactor_proto-{version_without_hash}-py3-none-any.whl
-version = "1.1.0-g20f00e2"
+version = "1.4.1-g5660eed"

{reactor_runtime-2.0.2 → reactor_runtime-2.2.0}/src/reactor_runtime/capabilities.py

@@ -24,15 +24,17 @@ from reactor_runtime.interface.model.input_fields import FieldInfo
 from reactor_runtime.interface.tracks.descriptors import Audio
 from reactor_runtime.interface.tracks.input import INPUT_REGISTRY
 from reactor_runtime.interface.tracks.output import OUTPUT_REGISTRY
+from reactor_runtime.interface.upload import UploadedFile
 
 
-CAPABILITIES_VERSION = "1.1"
+CAPABILITIES_VERSION = "1.2"
 
 _TYPE_MAP = {
     int: "integer",
     float: "number",
     str: "string",
     bool: "boolean",
+    UploadedFile: "file",
 }
 
 

{reactor_runtime-2.0.2 → reactor_runtime-2.2.0}/src/reactor_runtime/interface/__init__.py

@@ -19,11 +19,18 @@ from reactor_runtime.interface.tracks.output import (
 # Events & Messages
 from reactor_runtime.interface.events.event import EVENT_REGISTRY, Event
 from reactor_runtime.interface.events.connected import Connected, Disconnected
+from reactor_runtime.interface.events.upload import FileUploaded
+from reactor_runtime.interface.upload import UploadedFile
 from reactor_runtime.interface.events.messages import MESSAGE_REGISTRY, ModelMessage
 
 # Model layer (canonical) — includes decorators and field metadata
 from reactor_runtime.interface.model.reactor_model import ReactorModel
-from reactor_runtime.interface.model.decorators import connected, disconnected, event
+from reactor_runtime.interface.model.decorators import (
+    connected,
+    disconnected,
+    event,
+    file_uploaded,
+)
 from reactor_runtime.interface.model.input_fields import FieldInfo, InputField
 
 # Pipeline — generator + typed state layer
@@ -31,6 +38,9 @@ from reactor_runtime.interface.pipeline.reactor_pipeline import ReactorPipeline
 from reactor_runtime.interface.pipeline.input_state import InputState
 from reactor_runtime.interface.pipeline.idle import Idle
 
+# Driver — programmatic step-by-step control
+from reactor_runtime.interface.driver import PipelineExecutor, StepResult
+
 # Internal (exposed for runtime integration, not stable API)
 from reactor_runtime.interface.internal.reactor_core import ReactorCore
 from reactor_runtime.interface.internal.output_buffer import OutputBuffer
@@ -54,6 +64,8 @@ __all__ = [
     "Event",
     "Connected",
     "Disconnected",
+    "FileUploaded",
+    "UploadedFile",
     "EVENT_REGISTRY",
     "ModelMessage",
     "MESSAGE_REGISTRY",
@@ -62,12 +74,16 @@ __all__ = [
     "event",
     "connected",
     "disconnected",
+    "file_uploaded",
     "FieldInfo",
     "InputField",
     # Pipeline
     "ReactorPipeline",
     "InputState",
     "Idle",
+    # Driver
+    "PipelineExecutor",
+    "StepResult",
     # Internal
     "ReactorCore",
     "OutputBuffer",

reactor_runtime-2.2.0/src/reactor_runtime/interface/driver/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""Programmatic pipeline executor — step-by-step control without a server."""
+
+from reactor_runtime.interface.driver.pipeline_executor import PipelineExecutor
+from reactor_runtime.interface.driver.step_result import StepResult
+
+__all__ = ["PipelineExecutor", "StepResult"]

reactor_runtime-2.2.0/src/reactor_runtime/interface/driver/pipeline_executor.py

@@ -0,0 +1,297 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""PipelineExecutor — programmatic step-by-step control of a ReactorPipeline."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from typing import Any, Dict, Iterator, List, Optional, Type
+
+from reactor_runtime.interface.driver.step_result import StepResult
+from reactor_runtime.interface.events.messages import ModelMessage
+from reactor_runtime.interface.model.handlers import Handlers, build_dispatch_table
+from reactor_runtime.interface.model.input_fields import validate_field
+from reactor_runtime.interface.pipeline.idle import Idle
+from reactor_runtime.interface.pipeline.reactor_pipeline import (
+    GeneratorEnded,
+    ReactorPipeline,
+)
+
+
+class PipelineExecutor(Iterator[StepResult]):
+    """Execute a :class:`ReactorPipeline` step-by-step from synchronous code.
+
+    Wraps any ``ReactorPipeline`` subclass and exposes a clean
+    sequential API: ``connect()``, iteration via ``next()`` / ``for``,
+    ``send_event()``, ``push_media()``, ``disconnect()``.
+    No server, no transport, no background threads.
+
+    Implements ``Iterator[StepResult]`` — each call to ``next(exe)``
+    advances the inference generator by one ``yield``.  Iteration
+    stops with ``StopIteration`` when no session is active.
+
+    Each action returns the :class:`ModelMessage` instances the model
+    sent via ``self.send()`` during that action, enabling deterministic
+    assertions in tests and structured output capture in scripts.
+
+    Example::
+
+        with PipelineExecutor(EchoPipeline) as exe:
+            exe.connect()
+            exe.push_media("webcam", frame)
+            for r in exe:
+                if r.output is not Idle:
+                    break
+            msgs = exe.send_event("set_effect", effect="sepia")
+            exe.disconnect()
+    """
+
+    def __init__(
+        self,
+        pipeline_cls: Type[ReactorPipeline],
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        # Instantiate the pipeline and run its one-time load().
+        self._model: ReactorPipeline = pipeline_cls()
+        self._model.load(config or {})
+
+        # Build the handler dispatch table from @event / @connected /
+        # @disconnected decorators discovered on the pipeline class.
+        self._handlers: Handlers = self._model._get_handlers()
+        self._dispatch_table = build_dispatch_table(self._handlers)
+
+        # Private event loop — _advance() and some handlers are async,
+        # so we need a loop.  Everything still runs on the caller's
+        # thread; there are no background threads.
+        self._loop: asyncio.AbstractEventLoop = asyncio.new_event_loop()
+        self._loop.run_until_complete(self._init())
+
+        # Track whether inference() is sync or async so _advance()
+        # uses the right iteration protocol (next vs __anext__).
+        self._gen = None
+        self._is_async_gen: bool = inspect.isasyncgenfunction(self._model.inference)
+        self._model._async_inference = self._is_async_gen
+
+        # Message capture — override send() to collect ModelMessage
+        # instances instead of serializing them over transport.
+        # _run() clears this list before every action so that
+        # messages are scoped to the action that produced them.
+        self._captured: List[ModelMessage] = []
+
+        async def _capturing_send(message: ModelMessage) -> None:
+            self._captured.append(message)
+
+        self._model.send = _capturing_send  # type: ignore[assignment]
+
+    async def _init(self) -> None:
+        self._model._init_async()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def connect(self) -> List[ModelMessage]:
+        """Begin a session.
+
+        Creates a fresh :class:`InputState`, starts the ``inference()``
+        generator, sets the ``connected`` signal, and fires the
+        ``@connected`` handler if defined.
+
+        Returns:
+            Messages the model sent during the ``@connected`` handler.
+        """
+        if self._gen is not None:
+            raise RuntimeError(
+                "connect() called on an already-connected executor. "
+                "Call disconnect() first."
+            )
+        return self._run(self._connect())
+
+    def __iter__(self) -> Iterator[StepResult]:
+        """Return self — PipelineExecutor is its own iterator."""
+        return self
+
+    def __next__(self) -> StepResult:
+        """Advance the inference generator by one ``yield``.
+
+        Returns:
+            A :class:`StepResult` with the output, compute time, and
+            any messages sent during this step.
+
+        Raises:
+            StopIteration: No active session (before ``connect()``
+                or after ``disconnect()``).
+        """
+        if self._gen is None:
+            raise StopIteration
+        return self._run(self._step())
+
+    def send_event(self, name: str, **kwargs: Any) -> List[ModelMessage]:
+        """Deliver a named event to the model.
+
+        Validates strictly before calling the handler:
+
+        1. ``ValueError`` if the event name is unknown.
+        2. ``TypeError`` if the kwargs don't match the event dataclass.
+        3. ``ValueError`` if an ``InputField`` constraint is violated.
+
+        Returns:
+            Messages the model sent during the event handler.
+        """
+        entry = self._handlers.events.get(name)
+        if entry is None:
+            available = sorted(self._handlers.events.keys())
+            raise ValueError(f"Unknown event {name!r}. Available events: {available}")
+
+        try:
+            entry.event_cls(**kwargs)
+        except TypeError as exc:
+            raise TypeError(f"Invalid arguments for event {name!r}: {exc}") from None
+
+        field_infos: Dict = getattr(entry.event_cls, "_field_infos", {})
+        for field_name, info in field_infos.items():
+            if field_name in kwargs:
+                ok, reason = validate_field(field_name, kwargs[field_name], info)
+                if not ok:
+                    raise ValueError(f"Validation failed for event {name!r}: {reason}")
+
+        return self._run(self._send_event(entry, **kwargs))
+
+    def push_media(self, track_name: str, data: Any) -> None:
+        """Push a media frame into an input buffer.
+
+        The frame becomes available to the model on the next
+        iteration when ``inference()`` calls ``try_read()`` or
+        ``read()``.
+        """
+        self._model._push_media(track_name, data)
+
+    def disconnect(self) -> List[ModelMessage]:
+        """End the current session.
+
+        Clears the ``connected`` signal, fires the ``@disconnected``
+        handler, closes the generator, and resets state and buffers.
+
+        Returns:
+            Messages the model sent during the ``@disconnected`` handler.
+        """
+        if self._gen is None:
+            raise RuntimeError(
+                "disconnect() called without an active session. Call connect() first."
+            )
+        return self._run(self._disconnect())
+
+    @property
+    def state(self):
+        """The current session state, or ``None`` if no session is active."""
+        return self._model.state
+
+    def close(self) -> None:
+        """Shut down the executor.
+
+        Disconnects if a session is active and closes the event loop.
+        """
+        try:
+            if self._gen is not None:
+                self._run(self._disconnect())
+        finally:
+            if not self._loop.is_closed():
+                self._loop.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Async implementations
+    #
+    # Each method below is the async core of a public API method.
+    # The public wrappers delegate to these via _run(), which clears
+    # captured messages and runs the coroutine synchronously with
+    # run_until_complete().
+    # ------------------------------------------------------------------
+
+    async def _connect(self) -> List[ModelMessage]:
+        """Create a fresh InputState, start inference(), fire @connected."""
+        self._model.state = self._model._state_cls()
+        self._gen = self._model.inference()
+        self._model.connected.set()
+        await self._fire_handler(
+            self._handlers.connected,
+            self._handlers.connected_is_async,
+        )
+        return list(self._captured)
+
+    async def _step(self) -> StepResult:
+        """Advance the inference generator by one ``yield``.
+
+        On ``GeneratorEnded`` the generator is restarted automatically
+        (same behavior as the production run-loop) and ``Idle`` is
+        returned for that tick.
+        """
+        try:
+            output, compute_time = await self._model._advance(
+                self._gen, self._is_async_gen
+            )
+        except GeneratorEnded:
+            self._gen = self._model.inference()
+            return StepResult(
+                output=Idle, compute_time=0.0, messages=list(self._captured)
+            )
+        return StepResult(
+            output=output,
+            compute_time=compute_time,
+            messages=list(self._captured),
+        )
+
+    async def _send_event(self, entry: Any, **kwargs: Any) -> List[ModelMessage]:
+        """Dispatch a validated event to its handler function."""
+        await self._fire_handler(entry.handler, entry.is_async, **kwargs)
+        return list(self._captured)
+
+    async def _disconnect(self) -> List[ModelMessage]:
+        """Clear connected, fire @disconnected, close generator, reset state."""
+        self._model.connected.clear()
+        await self._fire_handler(
+            self._handlers.disconnected,
+            self._handlers.disconnected_is_async,
+        )
+        if self._gen is not None:
+            if self._is_async_gen:
+                await self._gen.aclose()
+            else:
+                self._gen.close()
+            self._gen = None
+        self._model.state = None
+        for buf in self._model._input_buffers.values():
+            buf.reset()
+        return list(self._captured)
+
+    # ------------------------------------------------------------------
+    # Infrastructure
+    # ------------------------------------------------------------------
+
+    async def _fire_handler(
+        self,
+        handler: Any,
+        is_async: bool,
+        **kwargs: Any,
+    ) -> None:
+        """Call a lifecycle or event handler, dispatching sync/async."""
+        if handler is None:
+            return
+        if is_async:
+            await handler(self._model, **kwargs)
+        else:
+            handler(self._model, **kwargs)
+
+    def _run(self, coro: Any) -> Any:
+        """Clear captured messages then run *coro* synchronously.
+
+        The clear-before-run pattern scopes messages: each public
+        action sees only the messages produced during that action.
+        """
+        self._captured.clear()
+        return self._loop.run_until_complete(coro)

reactor_runtime-2.2.0/src/reactor_runtime/interface/driver/step_result.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""StepResult — return type of ``next(PipelineExecutor)``."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Union
+
+from reactor_runtime.interface.events.messages import ModelMessage
+from reactor_runtime.interface.pipeline.idle import _IdleType
+from reactor_runtime.interface.tracks.output import Output
+
+
+@dataclass
+class StepResult:
+    """Result of a single inference step.
+
+    Attributes:
+        output: The resolved :class:`Output` instance that the
+            generator yielded, or :data:`Idle` when it yielded
+            ``Idle`` or ``None``.
+        compute_time: Wall-clock seconds spent inside the generator
+            for this step (excludes transport and emission overhead).
+        messages: :class:`ModelMessage` instances the model sent via
+            ``self.send()`` during this step.
+    """
+
+    output: Union[Output, _IdleType]
+    compute_time: float
+    messages: List[ModelMessage] = field(default_factory=list)

reactor_runtime-2.2.0/src/reactor_runtime/interface/events/upload.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""Built-in file upload lifecycle event — :class:`FileUploaded`."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from reactor_runtime.interface.events.event import Event
+from reactor_runtime.interface.upload import UploadedFile
+
+
+@dataclass
+class FileUploaded(Event, internal=True):  # type: ignore[call-arg]
+    """Fired when an uploaded file has been downloaded and is ready.
+
+    Handle with the ``@file_uploaded`` decorator on your model method.
+    This is a lifecycle event pushed by the runtime — clients cannot
+    trigger it via the data channel.
+    """
+
+    file: UploadedFile

{reactor_runtime-2.0.2 → reactor_runtime-2.2.0}/src/reactor_runtime/interface/model/decorators.py

@@ -1,6 +1,6 @@
 # Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
 """
-Model decorators — ``@connected``, ``@disconnected``, and ``@event``.
+Model decorators — ``@connected``, ``@disconnected``, ``@file_uploaded``, and ``@event``.
 """
 
 from __future__ import annotations
@@ -12,9 +12,11 @@ from typing import Any, Callable, List, Tuple, Type, Union, get_type_hints
 
 from reactor_runtime.interface.events.event import Event, _snake_to_pascal
 from reactor_runtime.interface.model.input_fields import FieldInfo, _NO_DEFAULT
+from reactor_runtime.interface.upload import UploadedFile
 
 _CONNECTED_ATTR = "__reactor_connected__"
 _DISCONNECTED_ATTR = "__reactor_disconnected__"
+_FILE_UPLOADED_ATTR = "__reactor_file_uploaded__"
 _EVENT_HANDLER_ATTR = "__reactor_event_meta__"
 _IS_ASYNC_ATTR = "__reactor_is_async__"
 
@@ -59,6 +61,36 @@ def disconnected(func: Callable) -> Callable:
     return func
 
 
+def file_uploaded(func: Callable) -> Callable:
+    """Mark a method as the handler called when a file is uploaded.
+
+    Called each time the client uploads a file to the runtime.
+    Only one ``@file_uploaded`` handler is allowed per model class.
+    The handler receives a single ``uploaded_file`` keyword argument
+    of type :class:`UploadedFile`.  The handler may be ``async def``
+    or a plain ``def``.
+
+    Example::
+
+        @file_uploaded
+        async def on_file(self, uploaded_file: UploadedFile):
+            if uploaded_file.mime_type.startswith("image/"):
+                pil_image = Image.open(io.BytesIO(uploaded_file.data))
+    """
+    if not callable(func):
+        raise TypeError(f"@file_uploaded expected a callable, got {type(func)}")
+    sig = inspect.signature(func)
+    params = [p for p in sig.parameters if p != "self"]
+    if params != ["uploaded_file"]:
+        raise TypeError(
+            f"@file_uploaded handler must accept exactly one parameter named "
+            f"'uploaded_file', got: {params}"
+        )
+    setattr(func, _FILE_UPLOADED_ATTR, True)
+    setattr(func, _IS_ASYNC_ATTR, inspect.iscoroutinefunction(func))
+    return func
+
+
 def event(*, name: str, description: str = "", dedupe: bool = False):
     """Mark a method as a named event handler.
 
@@ -143,12 +175,16 @@ def _make_event_from_method(func: Callable, event_name: str) -> Type[Event]:
 
     fields: list = []
     field_infos: dict[str, FieldInfo] = {}
+    upload_fields: set[str] = set()
 
     for param_name, param in sig.parameters.items():
         if param_name == "self":
             continue
         param_type = hints.get(param_name, Any)
 
+        if param_type is UploadedFile:
+            upload_fields.add(param_name)
+
         if param.default != inspect.Parameter.empty:
             raw_default = param.default
             if isinstance(raw_default, FieldInfo):
@@ -175,4 +211,7 @@ def _make_event_from_method(func: Callable, event_name: str) -> Type[Event]:
     if field_infos:
         event_cls._field_infos = field_infos  # type: ignore[attr-defined]
 
+    if upload_fields:
+        event_cls._upload_fields = upload_fields  # type: ignore[attr-defined]
+
     return event_cls

{reactor_runtime-2.0.2 → reactor_runtime-2.2.0}/src/reactor_runtime/interface/model/handlers.py

@@ -2,9 +2,9 @@
 """
 Handler collection and dispatch table construction.
 
-Scans a model class's MRO for ``@connected``, ``@disconnected``, and
-``@event`` decorated methods and builds a dispatch table used by
-:class:`ReactorModel`.
+Scans a model class's MRO for ``@connected``, ``@disconnected``,
+``@file_uploaded``, and ``@event`` decorated methods and builds a
+dispatch table used by :class:`ReactorModel`.
 """
 
 from __future__ import annotations
@@ -16,6 +16,7 @@ from reactor_runtime.interface.model.decorators import (
     _CONNECTED_ATTR,
     _DISCONNECTED_ATTR,
     _EVENT_HANDLER_ATTR,
+    _FILE_UPLOADED_ATTR,
     _IS_ASYNC_ATTR,
 )
 
@@ -48,6 +49,8 @@ class Handlers:
         "connected_is_async",
         "disconnected",
         "disconnected_is_async",
+        "file_uploaded",
+        "file_uploaded_is_async",
         "events",
     )
 
@@ -56,6 +59,8 @@ class Handlers:
         self.connected_is_async: bool = False
         self.disconnected: Optional[Callable] = None
         self.disconnected_is_async: bool = False
+        self.file_uploaded: Optional[Callable] = None
+        self.file_uploaded_is_async: bool = False
         self.events: Dict[str, EventEntry] = {}
 
 
@@ -78,6 +83,7 @@ def collect_handlers(cls: type, skip_classes: tuple = ()) -> Handlers:
 
         connected_in_class: List[Callable] = []
         disconnected_in_class: List[Callable] = []
+        file_uploaded_in_class: List[Callable] = []
 
         for _attr_name, attr_value in vars(klass).items():
             if not callable(attr_value):
@@ -89,6 +95,9 @@ def collect_handlers(cls: type, skip_classes: tuple = ()) -> Handlers:
             if getattr(attr_value, _DISCONNECTED_ATTR, False):
                 disconnected_in_class.append(attr_value)
 
+            if getattr(attr_value, _FILE_UPLOADED_ATTR, False):
+                file_uploaded_in_class.append(attr_value)
+
             meta = getattr(attr_value, _EVENT_HANDLER_ATTR, None)
             if meta is not None and meta["name"] not in seen_events:
                 handlers.events[meta["name"]] = EventEntry(
@@ -117,6 +126,11 @@ def collect_handlers(cls: type, skip_classes: tuple = ()) -> Handlers:
                 f"Multiple @disconnected handlers in {klass.__qualname__}: "
                 f"{[f.__qualname__ for f in disconnected_in_class]}"
             )
+        if len(file_uploaded_in_class) > 1:
+            raise TypeError(
+                f"Multiple @file_uploaded handlers in {klass.__qualname__}: "
+                f"{[f.__qualname__ for f in file_uploaded_in_class]}"
+            )
 
         if connected_in_class and handlers.connected is None:
             handlers.connected = connected_in_class[0]
@@ -132,6 +146,13 @@ def collect_handlers(cls: type, skip_classes: tuple = ()) -> Handlers:
                 _IS_ASYNC_ATTR,
                 False,
             )
+        if file_uploaded_in_class and handlers.file_uploaded is None:
+            handlers.file_uploaded = file_uploaded_in_class[0]
+            handlers.file_uploaded_is_async = getattr(
+                file_uploaded_in_class[0],
+                _IS_ASYNC_ATTR,
+                False,
+            )
 
     return handlers
 

{reactor_runtime-2.0.2 → reactor_runtime-2.2.0}/src/reactor_runtime/interface/model/reactor_model.py

@@ -16,6 +16,7 @@ from typing import Any, Callable, List, Tuple, Type
 
 from reactor_runtime.interface.events.connected import Connected, Disconnected
 from reactor_runtime.interface.events.event import Event
+from reactor_runtime.interface.events.upload import FileUploaded
 from reactor_runtime.interface.model.handlers import (
     Handlers,
     build_dispatch_table,
@@ -156,6 +157,14 @@ class ReactorModel(ReactorCore):
                         handlers.disconnected_is_async,
                     )
 
+            elif isinstance(event, FileUploaded):
+                if handlers.file_uploaded is not None:
+                    await self._invoke(
+                        handlers.file_uploaded,
+                        handlers.file_uploaded_is_async,
+                        uploaded_file=event.file,
+                    )
+
             else:
                 await self._dispatch_event(event, dispatch_table)