H2O Wave Documentation

The repository is organized into the following key directories:

• cmd: Go executables.
• data: Contains data created by a Wave-app (e.g., file uploads).
• py: Python package.
• r: R package.
• tools/wavegen: TypeScript to Python/R code-generator.
• ui: TypeScript + React sources (primarily built using Fluent UI).
  • ui/config: Webpack configuration.
  • ui/eslint: Custom ESLint rules for ts and tsx files. (Note: If you change linter.js, you must run npm ci for changes to take effect).
• website: Documentation sources.

H2O Wave uses a retained-mode graphics model where the Wave server acts as a hub between the browser and your Python applications. To build applications, follow this workflow:

1. Your instance holds a collection of pages.
2. To change a page, grab a reference to the page, modify its content using the SDK, and then save it.

Once q.page.save() is called, changes are broadcasted to all connected clients in real-time without requiring a browser reload.

WaveDB is a lightweight, SQLite-based companion database that provides a HTTP interface for Wave applications.

Key Features:

• Self-contained: A single, zero-dependency executable.
• SQLite Bundled: Includes SQLite 3.35.5 with JSON1, RTREE, FTS5, GEOPOLY, STAT4, and SOUNDEX.
• Async Access: The h2o-wave package includes non-blocking async functions to interact with WaveDB.

Refer to the WaveDB Guide for installation and the WaveDB API documentation for usage details.

WaveML is a companion package designed to integrate machine learning models into Wave applications quickly. It provides a high-level API to:

• Train models
• Deploy models
• Score models
• Explain models

WaveML utilizes H2O's open-source AutoML and can optionally interface with Driverless AI. For implementation details, refer to the WaveML Guide and the WaveML API documentation.

H2O Wave operates using a three-part architecture: the Browser, the Wave Server, and the App Server.

• Browser ↔ Wave Server: Communication occurs via WebSockets.
• Wave Server ↔ App Server: Communication occurs via HTTP requests.

An App Server is essentially an HTTP server that must implement a single HTTP handler listening for POST requests at the root path (/).

Wave scripts are the simplest way to publish live web content, such as dashboards, visualizations, news tickers, or performance monitoring data.

Key distinction:

• Wave Scripts: Used for publishing content only. They are not interactive and cannot handle user interactions.
• Wave Apps: Designed for interactivity and handling user inputs/interactions.

WaveDB is a lightweight, self-contained companion database for Wave apps based on SQLite. It acts as a thin HTTP-server wrapper around SQLite, allowing you to access your databases over a network.

Key features:

• Based on SQLite 3.35.5.
• Includes extensions: JSON1, RTREE, FTS5, GEOPOLY, STAT4, and SOUNDEX.
• Zero-dependency, self-contained executable.
• Accessible via non-blocking async functions provided in the h2o-wave package.

Wave provides a flex layout system to build responsive user interfaces that adapt to different screen sizes. To use it, attach a layout to your page's meta card using ui.layout().

A layout requires a breakpoint and a set of zones. Zones can be nested and have a direction (ui.ZoneDirection.ROW or ui.ZoneDirection.COLUMN).

q.page['meta'] = ui.meta_card(box='', layouts=[
    ui.layout(
        breakpoint='xl',
        width='1200px',
        zones=[
            ui.zone('header'),
            ui.zone('body', direction=ui.ZoneDirection.ROW, zones=[
                ui.zone('content', size='75%'),
                ui.zone('sidebar', size='25%'),
            ]),
            ui.zone('footer'),
        ]
    )
])

Wave apps are ASGI-compatible. While you can use wave run your_app --no-reload for simple deployments, for production it is highly recommended to run the Wave server (waved) separately from the Wave app. You can run Wave apps using any ASGI server like uvicorn, gunicorn, daphne, or hypercorn.

To run an app with Uvicorn, append :main to the app filename. For example, if your app is foo.py, use uvicorn foo:main.