$ show reactive-python/reactpy
ReactPy is a Python library for building interactive web user interfaces using React-like components. Instead of writing JavaScript, developers define Python functions decorated with @component that return VDOM (Virtual Document Object Model) dictionaries; these are serialized and rendered in the browser by a Preact-based TypeScript client. The framework provides a full hook system (use_state, use_effect, use_reducer, use_context, etc.), an event-handling layer supporting debounce, throttle, and live browser-object proxies, and first-class ASGI integration via middleware or standalone ASGI apps. It also supports PyScript/Pyodide for running components entirely in the browser and importing actual ReactJS/NPM components from Python. The architecture is a hybrid library/framework: a Python core package (src/reactpy) handles component lifecycle, layout rendering, event dispatch, and state management, while a separate JavaScript client package (src/js/packages/@reactpy/client) handles DOM rendering and WebSocket communication. A notable design feature is the live event proxy, which avoids serializing entire browser event objects to the server; instead, the client holds event objects and lets Python code lazily read properties or invoke methods over a batched, security-blocklisted protocol. The project is well-tested with unit tests, Playwright-based integration tests, and CI across multiple Python versions and operating systems. It is not a data pipeline or research codebase; data-related content appears only as demo examples. The repository also contains substantial documentation, example galleries, build tooling for both Python and JavaScript, and testing fixtures that are useful for any project needing browser-backed backend testing. Some legacy APIs (e.g., reactpy.web) coexist with newer reactjs-based APIs, and the documentation has areas marked under construction, but the core code is actively maintained and demonstrates strong engineering practices.
The LLM identified 5 files worth highlighting for reuse:
Implements a lazy, live proxy for browser-side JavaScript objects. Python event handlers can read attributes and call methods on DOM event objects without sending the event's full data to the server. The component manages a registry of active proxies, batches requests, enforces timeouts, and handles eviction/cleanup. This is a novel, self-contained protocol pattern that could be adapted to other client-server reactive systems.
Core VDOM data model and validation layer. It defines the structure of UI trees (tagName, attributes, children, eventHandlers), flattens children, separates event handlers from attributes, warns on key-integrity issues, and validates against a hand-maintained JSON schema. This is a well-crafted example of a serializable, validated UI representation that is independent enough to be reused or studied for other declarative UI systems.
Provides DisplayFixture, a Playwright-backed test harness that launches a real browser, connects it to the component backend, and exposes polling and assertion helpers for interactive UI behavior. This is a genuinely reusable pattern for end-to-end testing of any server-rendered reactive UI, not just ReactPy, and it demonstrates advanced async-test tooling.
Implements ReactPyMiddleware, a composable ASGI middleware that routes HTTP, WebSocket, and static-file requests and dispatches component mount points by dotted path. It also supports custom lifespan/custom routes and can wrap arbitrary ASGI applications. This is a clean, reusable pattern for embedding component-rendering servers inside larger ASGI apps.
Client-side counterpart to the Python event proxy. It maintains live JavaScript event objects, serves on-demand property reads and method calls, batches responses, and enforces a security blocklist to prevent DOM escape via window/document/prototype access. This is a sophisticated, reusable pattern for safely exposing browser object graphs to remote (server-side) code over a websocket.