plexus-python 0.1.0__tar.gz → 0.3.0__tar.gz

plexus_python-0.3.0/AGENTS.md

@@ -0,0 +1,72 @@
+# AGENTS.md — plexus-python
+
+Machine-readable interface for AI assistants and automation scripts.
+
+## Environment Variables
+
+| Variable                | Description                                  | Default                          |
+| ----------------------- | -------------------------------------------- | -------------------------------- |
+| `PLEXUS_API_KEY`        | API key for authentication (required)        | none                             |
+| `PLEXUS_GATEWAY_URL`    | Gateway HTTP ingest URL                      | `https://plexus-gateway.fly.dev` |
+| `PLEXUS_GATEWAY_WS_URL` | Gateway WebSocket URL                        | `wss://plexus-gateway.fly.dev`   |
+
+## CLI Commands
+
+```bash
+plexus start                           # Stream with PLEXUS_API_KEY env var
+plexus start --key plx_xxxxx           # Pass key inline
+plexus start --device-id my-device     # Set device identifier
+plexus reset                           # Clear config
+```
+
+An API key is required — set `PLEXUS_API_KEY` or pass `--key`. There is no interactive signup; get a key at app.plexus.company/devices.
+
+## Exit Codes
+
+| Code  | Meaning                               |
+| ----- | ------------------------------------- |
+| `0`   | Clean shutdown                        |
+| `1`   | Configuration or authentication error |
+| `130` | Interrupted (SIGINT / Ctrl+C)         |
+
+## Python SDK
+
+```python
+from plexus import Plexus
+
+px = Plexus(api_key="plx_xxxxx", source_id="device-001")
+px.send("temperature", 72.5)
+px.send("pressure", 1013.25, tags={"unit": "hPa"})
+
+# Batch
+px.send_batch([
+    ("temperature", 72.5),
+    ("pressure", 1013.25),
+])
+
+# Persistent buffering for reliability
+px = Plexus(api_key="plx_xxxxx", persistent_buffer=True)
+```
+
+## Project Structure
+
+```
+plexus/
+├── cli.py          # CLI entry point (click commands)
+├── tui.py          # Live terminal dashboard (Rich)
+├── client.py       # Plexus HTTP client (thin SDK)
+├── connector.py    # WebSocket daemon
+├── config.py       # Config file + env var management
+├── detect.py       # Hardware auto-detection
+├── deps.py         # Dependency helpers
+├── sensors/        # I2C sensor drivers + SensorHub
+└── adapters/       # Protocol adapters: CAN, MAVLink, MQTT, Modbus, OPC-UA, BLE, Serial
+```
+
+## Key Conventions
+
+- Config lives in `~/.plexus/config.json`
+- API keys are prefixed with `plx_`
+- Source IDs (device slugs) namespace metrics
+- HTTP ingest → `POST /ingest` on gateway; WebSocket → `/ws/device` for streaming + commands
+- Gateway resolves `org_id` server-side from the API key — clients do not supply it

{plexus_python-0.1.0 → plexus_python-0.3.0}/API.md

@@ -30,7 +30,7 @@ Then control streaming, recording, and configuration from [app.plexus.company/de
 Send data directly via HTTP:
 
 ```bash
-curl -X POST https://app.plexus.company/api/ingest \
+curl -X POST https://plexus-gateway.fly.dev/ingest \
   -H "x-api-key: YOUR_API_KEY" \
   -H "Content-Type: application/json" \
   -d '{
@@ -280,7 +280,7 @@ import requests
 import time
 
 requests.post(
-    "https://app.plexus.company/api/ingest",
+    "https://plexus-gateway.fly.dev/ingest",
     headers={"x-api-key": "plx_xxxxx"},
     json={
         "points": [{
@@ -296,7 +296,7 @@ requests.post(
 ### JavaScript
 
 ```javascript
-await fetch("https://app.plexus.company/api/ingest", {
+await fetch("https://plexus-gateway.fly.dev/ingest", {
   method: "POST",
   headers: {
     "x-api-key": "plx_xxxxx",
@@ -338,7 +338,7 @@ func main() {
     }
 
     body, _ := json.Marshal(points)
-    req, _ := http.NewRequest("POST", "https://app.plexus.company/api/ingest", bytes.NewBuffer(body))
+    req, _ := http.NewRequest("POST", "https://plexus-gateway.fly.dev/ingest", bytes.NewBuffer(body))
     req.Header.Set("x-api-key", "plx_xxxxx")
     req.Header.Set("Content-Type", "application/json")
 
@@ -354,7 +354,7 @@ func main() {
 
 void sendToPlexus(const char* metric, float value) {
     HTTPClient http;
-    http.begin("https://app.plexus.company/api/ingest");
+    http.begin("https://plexus-gateway.fly.dev/ingest");
     http.addHeader("Content-Type", "application/json");
     http.addHeader("x-api-key", "plx_xxxxx");
 
@@ -377,7 +377,7 @@ void sendToPlexus(const char* metric, float value) {
 API_KEY="plx_xxxxx"
 SOURCE_ID="sensor-001"
 
-curl -X POST https://app.plexus.company/api/ingest \
+curl -X POST https://plexus-gateway.fly.dev/ingest \
   -H "x-api-key: $API_KEY" \
   -H "Content-Type: application/json" \
   -d "{
@@ -390,69 +390,38 @@ curl -X POST https://app.plexus.company/api/ingest \
   }"
 ```
 
-## Protocol Adapters
+## Bring Your Own Protocol
 
-Plexus supports protocol adapters for ingesting data from various sources.
-
-### CAN Bus Adapter
-
-Read CAN bus data with optional DBC signal decoding:
-
-```bash
-pip install plexus-python[can]
-```
+For MAVLink, CAN, MQTT, Modbus, OPC-UA, BLE, Serial, or any other protocol, use the upstream Python library directly and pass values to `px.send()`. Plexus stays out of your decode path:
 
 ```python
-from plexus.adapters import CANAdapter
+# CAN example — using python-can directly
+import can
 from plexus import Plexus
 
-plexus = Plexus(api_key="plx_xxx", source_id="vehicle-001")
-adapter = CANAdapter(
-    interface="socketcan",
-    channel="can0",
-    dbc_path="vehicle.dbc",  # Optional: decode signals
-)
+px = Plexus(api_key="plx_xxx", source_id="vehicle-001")
+bus = can.interface.Bus(channel="can0", bustype="socketcan")
 
-with adapter:
-    while True:
-        for metric in adapter.poll():
-            # Raw: can.raw.0x123 = "DEADBEEF"
-            # Decoded: engine_rpm = 2500
-            plexus.send(metric.name, metric.value, tags=metric.tags)
+for msg in bus:
+    px.send(f"can.0x{msg.arbitration_id:x}", int.from_bytes(msg.data, "big"))
 ```
 
-**Setup virtual CAN for testing (Linux):**
-
-```bash
-sudo modprobe vcan
-sudo ip link add dev vcan0 type vcan
-sudo ip link set up vcan0
-
-# Send test frames
-cansend vcan0 123#DEADBEEF
-```
-
-**Supported interfaces:** socketcan, pcan, vector, kvaser, slcan, virtual
-
-### MQTT Adapter
+```python
+# MAVLink example — using pymavlink directly
+from pymavlink import mavutil
+from plexus import Plexus
 
-Bridge MQTT brokers to Plexus:
+px = Plexus(api_key="plx_xxx", source_id="drone-001")
+conn = mavutil.mavlink_connection("udpin:0.0.0.0:14550")
 
-```bash
-pip install plexus-python[mqtt]
+while True:
+    msg = conn.recv_match(blocking=True)
+    if msg.get_type() == "ATTITUDE":
+        px.send("attitude.roll", msg.roll)
+        px.send("attitude.pitch", msg.pitch)
 ```
 
-```python
-from plexus.adapters import MQTTAdapter
-
-adapter = MQTTAdapter(
-    broker="localhost",
-    topic="sensors/#",
-    port=1883,
-)
-adapter.connect()
-adapter.run(on_data=my_callback)
-```
+See [docs.plexus.dev/recipes](https://docs.plexus.dev/recipes) for more.
 
 ## Python SDK with Sensor Drivers
 

plexus_python-0.3.0/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+## [0.3.0] - WebSocket transport
+
+Adds a wire-compatible WebSocket transport matching the `plexus-c` SDK. WS is now the default; failed sends transparently fall back to `POST /ingest`.
+
+### Added
+
+- `plexus.WebSocketTransport` — connects to `/ws/device` on the gateway. Exchanges the same `device_auth` / `authenticated` / `telemetry` / `heartbeat` / `typed_command` / `command_result` frames as `plexus-c`.
+- `Plexus(transport="ws" | "http")` — defaults to `"ws"`.
+- `Plexus.on_command(name, handler, description=..., params=...)` — register command handlers; automatic `ack`, handler return becomes `result`, exceptions become `error`.
+- `Plexus.close()` — stops the WebSocket thread.
+- Runtime dep: `websocket-client>=1.7`.
+- Tests: `tests/test_ws.py` (auth handshake, telemetry, command roundtrip, error paths).
+
+## [0.2.0] - Thin SDK rewrite
+
+Breaking. `plexus-python` is now just the thin client — no agent, adapters, sensors, CLI, or TUI. The package is 886 lines with one runtime dependency (`requests`). Protocol integrations (MAVLink, CAN, MQTT, Modbus, OPC-UA, BLE, I2C sensors) now live as standalone recipes in `examples/`, using the upstream library directly (`pymavlink`, `python-can`, `paho-mqtt`, etc.) plus `px.send()`.
+
+### Added
+
+- 5 runnable example scripts: `basic.py`, `mavlink.py`, `can.py`, `mqtt.py`, `i2c_bme280.py`
+
+### Removed
+
+- `plexus/adapters/` (MAVLink, CAN, MQTT, Modbus, OPC-UA, BLE, Serial — use the upstream lib directly)
+- `plexus/sensors/` (I2C drivers + auto-detect — use Adafruit CircuitPython or smbus2 directly)
+- `plexus/cameras/` (frame upload — out of scope)
+- `plexus/cli.py`, `plexus/connector.py`, `plexus/streaming.py`, `plexus/detect.py`, `plexus/tui.py`, `plexus/deps.py`
+- `plexus` console script, `python -m plexus`
+- Extras: `[sensors]`, `[system]`, `[tui]`, `[mqtt]`, `[can]`, `[mavlink]`, `[modbus]`, `[opcua]`, `[ble]`, `[serial]`, `[ros]`, `[camera]`, `[picamera]`, `[all]`
+- Runtime deps: `click`, `websockets`
+
+### Changed
+
+- Default ingest endpoint points directly at the Plexus gateway (`https://plexus-gateway.fly.dev/ingest`), not the Next.js app proxy
+- Client raises `ValueError` clearly when no API key is available, instead of invoking a login flow
+
+## [0.1.0] - Initial release
+
+- `Plexus` thin client for HTTP ingest
+- `plexus start` daemon with WebSocket streaming
+- Protocol adapters: MAVLink, CAN, MQTT, Modbus, OPC-UA, Serial, BLE
+- I2C sensor auto-detection and drivers
+- Store-and-forward buffering (SQLite)

plexus_python-0.3.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: plexus-python
+Version: 0.3.0
+Summary: Thin Python SDK for Plexus — send telemetry in one line
+Project-URL: Homepage, https://plexus.dev
+Project-URL: Documentation, https://docs.plexus.dev
+Project-URL: Repository, https://github.com/plexus-oss/plexus-python
+Project-URL: Issues, https://github.com/plexus-oss/plexus-python/issues
+Author-email: Plexus <hello@plexus.dev>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: fleet,hardware,iot,monitoring,observability,telemetry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.28.0
+Requires-Dist: websocket-client>=1.7
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: websockets>=12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# plexus-python
+
+**Thin Python SDK for [Plexus](https://plexus.company).** Send telemetry to the Plexus gateway in one line. Storage, dashboards, alerts, and fleet management live in the platform — this package just ships your data.
+
+[![PyPI](https://img.shields.io/pypi/v/plexus-python)](https://pypi.org/project/plexus-python/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
+
+## Quick Start
+
+```bash
+pip install plexus-python
+```
+
+```python
+from plexus import Plexus
+
+px = Plexus(api_key="plx_xxx", source_id="device-001")
+px.send("temperature", 72.5)
+```
+
+Get an API key at [app.plexus.company](https://app.plexus.company) → Devices → Add Device.
+
+## Usage
+
+```python
+from plexus import Plexus
+
+px = Plexus(source_id="rig-01")   # reads PLEXUS_API_KEY from env
+
+# Numbers
+px.send("engine.rpm", 3450)
+px.send("coolant.temperature", 82.3, tags={"unit": "C"})
+
+# Strings, bools, objects, arrays — all JSON-serializable
+px.send("vehicle.state", "RUNNING")
+px.send("motor.enabled", True)
+px.send("position", {"x": 1.5, "y": 2.3, "z": 0.8})
+
+# Batch
+px.send_batch([
+    ("temperature", 72.5),
+    ("pressure", 1013.25),
+])
+
+# Named run for grouping related data
+with px.run("thermal-cycle-001"):
+    while running:
+        px.send("temperature", read_temp())
+```
+
+## Bring Your Own Protocol
+
+This package ships no adapters, auto-detection, or daemons — just the client. Use whatever library you'd use anyway and pipe values into `px.send()`.
+
+```python
+# MAVLink (pymavlink)
+for msg in conn:
+    if msg.get_type() == "ATTITUDE":
+        px.send("attitude.roll", msg.roll)
+
+# CAN (python-can)
+for msg in bus:
+    px.send(f"can.0x{msg.arbitration_id:x}", int.from_bytes(msg.data, "big"))
+
+# MQTT (paho-mqtt)
+def on_message(_c, _u, msg):
+    px.send(msg.topic.replace("/", "."), float(msg.payload))
+
+# I2C sensor (Adafruit CircuitPython)
+px.send("temperature", bme.temperature)
+```
+
+See [`examples/`](examples/) for runnable versions of each.
+
+## Reliability
+
+Every send buffers locally before hitting the network, retries with exponential backoff, and keeps your data safe across outages. Enable SQLite persistence to survive restarts and power loss:
+
+```python
+px = Plexus(persistent_buffer=True)
+```
+
+Point counts and flush:
+
+```python
+px.buffer_size()
+px.flush_buffer()
+```
+
+## Transport
+
+By default the SDK connects over a **WebSocket** to `/ws/device` on the gateway — same wire protocol as the C SDK. This gives you:
+
+- lower-latency streaming of telemetry,
+- live command delivery from the UI / API to the device.
+
+If the socket is unavailable, sends transparently fall back to `POST /ingest` so no data is lost.
+
+```python
+# default — ws with http fallback
+px = Plexus()
+
+# force http (legacy)
+px = Plexus(transport="http")
+```
+
+### Handling commands
+
+Register a handler before the first `send()` so the command is advertised in the auth frame:
+
+```python
+def reboot(name, params):
+    delay = params.get("delay_s", 0)
+    # ... reboot logic ...
+    return {"ok": True, "delay": delay}
+
+px = Plexus()
+px.on_command("reboot", reboot, description="reboot the device")
+px.send("temperature", 72.5)   # opens the socket, waits for auth
+```
+
+The SDK sends an `ack` frame before invoking the handler, then a `result` frame with whatever the handler returns (or an `error` frame if it raises).
+
+## Environment Variables
+
+| Variable                | Description                  | Default                          |
+| ----------------------- | ---------------------------- | -------------------------------- |
+| `PLEXUS_API_KEY`        | API key (required)           | none                             |
+| `PLEXUS_GATEWAY_URL`    | HTTP ingest URL              | `https://plexus-gateway.fly.dev` |
+| `PLEXUS_GATEWAY_WS_URL` | WebSocket URL              | `wss://plexus-gateway.fly.dev`   |
+
+## Architecture
+
+```
+Your code ── px.send() ── HTTP POST /ingest ──> plexus-gateway ──> ClickHouse + Dashboard
+```
+
+One thin path. No agent, no daemon, no adapters. If you want the full HardwareOps platform — dashboards, alerts, RCA, fleet views — that's the web UI at app.plexus.company. This package gets your data there.
+
+## License
+
+Apache 2.0

plexus_python-0.3.0/README.md

@@ -0,0 +1,142 @@
+# plexus-python
+
+**Thin Python SDK for [Plexus](https://plexus.company).** Send telemetry to the Plexus gateway in one line. Storage, dashboards, alerts, and fleet management live in the platform — this package just ships your data.
+
+[![PyPI](https://img.shields.io/pypi/v/plexus-python)](https://pypi.org/project/plexus-python/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
+
+## Quick Start
+
+```bash
+pip install plexus-python
+```
+
+```python
+from plexus import Plexus
+
+px = Plexus(api_key="plx_xxx", source_id="device-001")
+px.send("temperature", 72.5)
+```
+
+Get an API key at [app.plexus.company](https://app.plexus.company) → Devices → Add Device.
+
+## Usage
+
+```python
+from plexus import Plexus
+
+px = Plexus(source_id="rig-01")   # reads PLEXUS_API_KEY from env
+
+# Numbers
+px.send("engine.rpm", 3450)
+px.send("coolant.temperature", 82.3, tags={"unit": "C"})
+
+# Strings, bools, objects, arrays — all JSON-serializable
+px.send("vehicle.state", "RUNNING")
+px.send("motor.enabled", True)
+px.send("position", {"x": 1.5, "y": 2.3, "z": 0.8})
+
+# Batch
+px.send_batch([
+    ("temperature", 72.5),
+    ("pressure", 1013.25),
+])
+
+# Named run for grouping related data
+with px.run("thermal-cycle-001"):
+    while running:
+        px.send("temperature", read_temp())
+```
+
+## Bring Your Own Protocol
+
+This package ships no adapters, auto-detection, or daemons — just the client. Use whatever library you'd use anyway and pipe values into `px.send()`.
+
+```python
+# MAVLink (pymavlink)
+for msg in conn:
+    if msg.get_type() == "ATTITUDE":
+        px.send("attitude.roll", msg.roll)
+
+# CAN (python-can)
+for msg in bus:
+    px.send(f"can.0x{msg.arbitration_id:x}", int.from_bytes(msg.data, "big"))
+
+# MQTT (paho-mqtt)
+def on_message(_c, _u, msg):
+    px.send(msg.topic.replace("/", "."), float(msg.payload))
+
+# I2C sensor (Adafruit CircuitPython)
+px.send("temperature", bme.temperature)
+```
+
+See [`examples/`](examples/) for runnable versions of each.
+
+## Reliability
+
+Every send buffers locally before hitting the network, retries with exponential backoff, and keeps your data safe across outages. Enable SQLite persistence to survive restarts and power loss:
+
+```python
+px = Plexus(persistent_buffer=True)
+```
+
+Point counts and flush:
+
+```python
+px.buffer_size()
+px.flush_buffer()
+```
+
+## Transport
+
+By default the SDK connects over a **WebSocket** to `/ws/device` on the gateway — same wire protocol as the C SDK. This gives you:
+
+- lower-latency streaming of telemetry,
+- live command delivery from the UI / API to the device.
+
+If the socket is unavailable, sends transparently fall back to `POST /ingest` so no data is lost.
+
+```python
+# default — ws with http fallback
+px = Plexus()
+
+# force http (legacy)
+px = Plexus(transport="http")
+```
+
+### Handling commands
+
+Register a handler before the first `send()` so the command is advertised in the auth frame:
+
+```python
+def reboot(name, params):
+    delay = params.get("delay_s", 0)
+    # ... reboot logic ...
+    return {"ok": True, "delay": delay}
+
+px = Plexus()
+px.on_command("reboot", reboot, description="reboot the device")
+px.send("temperature", 72.5)   # opens the socket, waits for auth
+```
+
+The SDK sends an `ack` frame before invoking the handler, then a `result` frame with whatever the handler returns (or an `error` frame if it raises).
+
+## Environment Variables
+
+| Variable                | Description                  | Default                          |
+| ----------------------- | ---------------------------- | -------------------------------- |
+| `PLEXUS_API_KEY`        | API key (required)           | none                             |
+| `PLEXUS_GATEWAY_URL`    | HTTP ingest URL              | `https://plexus-gateway.fly.dev` |
+| `PLEXUS_GATEWAY_WS_URL` | WebSocket URL              | `wss://plexus-gateway.fly.dev`   |
+
+## Architecture
+
+```
+Your code ── px.send() ── HTTP POST /ingest ──> plexus-gateway ──> ClickHouse + Dashboard
+```
+
+One thin path. No agent, no daemon, no adapters. If you want the full HardwareOps platform — dashboards, alerts, RCA, fleet views — that's the web UI at app.plexus.company. This package gets your data there.
+
+## License
+
+Apache 2.0

plexus_python-0.3.0/examples/README.md

@@ -0,0 +1,13 @@
+# Examples
+
+Each script is standalone — copy into your project, adjust the `source_id`, and run. Every example takes `PLEXUS_API_KEY` from the environment.
+
+| Script | What it shows | Extra deps |
+| --- | --- | --- |
+| `basic.py` | The 3-line starter | none |
+| `mavlink.py` | Drone / autopilot telemetry | `pymavlink` |
+| `can.py` | Vehicle CAN bus (with optional DBC decode) | `python-can`, `cantools` |
+| `mqtt.py` | MQTT broker → Plexus bridge | `paho-mqtt` |
+| `i2c_bme280.py` | Raspberry Pi environmental sensor | `adafruit-circuitpython-bme280` |
+
+The pattern is always the same: use whatever library you'd use anyway, then call `px.send(metric, value)`. Plexus stays out of your decode path.

plexus_python-0.3.0/examples/basic.py

@@ -0,0 +1,19 @@
+"""
+Basic telemetry — the 3-line starter.
+
+Run:
+    export PLEXUS_API_KEY=plx_xxx
+    python basic.py
+"""
+
+import random
+import time
+
+from plexus import Plexus
+
+px = Plexus(source_id="demo-device")
+
+while True:
+    px.send("temperature", 20 + random.random() * 5)
+    px.send("humidity", 40 + random.random() * 10)
+    time.sleep(1)

plexus_python-0.3.0/examples/can.py

@@ -0,0 +1,40 @@
+"""
+Pipe CAN bus frames into Plexus.
+
+Prereq:
+    pip install plexus-python python-can cantools
+    sudo ip link set can0 type can bitrate 500000 && sudo ip link set can0 up
+    export PLEXUS_API_KEY=plx_xxx
+
+Run:
+    python can.py can0 [vehicle.dbc]
+"""
+
+import sys
+
+import can
+import cantools
+
+from plexus import Plexus
+
+channel = sys.argv[1] if len(sys.argv) > 1 else "can0"
+dbc_path = sys.argv[2] if len(sys.argv) > 2 else None
+
+px = Plexus(source_id="vehicle-001")
+bus = can.interface.Bus(channel=channel, bustype="socketcan")
+db = cantools.database.load_file(dbc_path) if dbc_path else None
+
+for msg in bus:
+    if db:
+        try:
+            decoded = db.decode_message(msg.arbitration_id, msg.data)
+            for name, value in decoded.items():
+                if isinstance(value, (int, float)):
+                    px.send(name, value)
+            continue
+        except KeyError:
+            pass
+    px.send(
+        f"can.raw.0x{msg.arbitration_id:x}",
+        int.from_bytes(msg.data, "big"),
+    )

plexus_python-0.3.0/examples/i2c_bme280.py

@@ -0,0 +1,30 @@
+"""
+Read a BME280 over I2C on a Raspberry Pi and stream to Plexus.
+
+Prereq:
+    pip install plexus-python adafruit-circuitpython-bme280
+    sudo usermod -aG i2c $USER && reboot    # (once)
+    export PLEXUS_API_KEY=plx_xxx
+
+Run:
+    python i2c_bme280.py
+"""
+
+import time
+
+import board
+import busio
+from adafruit_bme280 import basic as adafruit_bme280
+
+from plexus import Plexus
+
+i2c = busio.I2C(board.SCL, board.SDA)
+bme = adafruit_bme280.Adafruit_BME280_I2C(i2c)
+
+px = Plexus(source_id="pi-lab-01")
+
+while True:
+    px.send("temperature", bme.temperature)
+    px.send("humidity", bme.relative_humidity)
+    px.send("pressure", bme.pressure)
+    time.sleep(2)