hapbeat-python-sdk 0.1.0__py3-none-any.whl

hapbeat/osc.py

@@ -0,0 +1,126 @@
+"""Generic OSC -> Hapbeat bridge.
+
+Lets any OSC-capable tool (TouchOSC, Max/MSP, TouchDesigner, a DAW, vvvv, ...)
+drive Hapbeat without writing code, using the addresses defined in
+``hapbeat-contracts/specs/message-format.md`` §6::
+
+    /hapbeat/play      event_id [target] [target_time_us] [gain]
+    /hapbeat/stop      event_id [target]
+    /hapbeat/stop-all  [target]
+    /hapbeat/ping
+
+This is the *transport* form of OSC (speak directly to Hapbeat). App-specific
+schemas (VRChat avatar parameters, etc.) are handled by dedicated bridges that
+translate the foreign schema into these calls.
+
+Requires the optional dependency::
+
+    pip install "hapbeat-python-sdk[osc]"
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from .hapbeat import Hapbeat
+
+logger = logging.getLogger("hapbeat.osc")
+
+# Layer 1 OSC port (hapbeat-contracts/specs/message-format.md §2).
+DEFAULT_OSC_PORT = 7702
+
+
+def _require_pythonosc():
+    try:
+        from pythonosc.dispatcher import Dispatcher
+        from pythonosc.osc_server import BlockingOSCUDPServer
+    except ImportError as exc:  # pragma: no cover - import-time guard
+        raise ImportError(
+            "OSC support needs python-osc. Install with: pip install \"hapbeat-python-sdk[osc]\""
+        ) from exc
+    return Dispatcher, BlockingOSCUDPServer
+
+
+class OscBridge:
+    """Listen for ``/hapbeat/*`` OSC messages and relay them to devices."""
+
+    def __init__(
+        self,
+        hb: Hapbeat,
+        listen_host: str = "0.0.0.0",
+        listen_port: int = DEFAULT_OSC_PORT,
+    ) -> None:
+        self.hb = hb
+        self.listen_host = listen_host
+        self.listen_port = listen_port
+        self._server = None
+
+    # ── Handlers (defensive about omitted trailing OSC args) ────────
+    # An omitted target is passed as None (not "") so the bound EventMap's
+    # per-event target (haptic file) applies; an explicit OSC target overrides.
+    def _handle_play(self, _address: str, *args) -> None:
+        event_id = str(args[0]) if len(args) >= 1 else ""
+        if not event_id:
+            return
+        target = str(args[1]) if len(args) >= 2 and args[1] != "" else None
+        target_time = int(args[2]) if len(args) >= 3 else 0
+        gain = float(args[3]) if len(args) >= 4 else None
+        self.hb.play(event_id, gain, target=target, target_time_us=target_time)
+
+    def _handle_stop(self, _address: str, *args) -> None:
+        if not args:
+            return
+        target = str(args[1]) if len(args) >= 2 and args[1] != "" else None
+        self.hb.stop(str(args[0]), target=target)
+
+    def _handle_stop_all(self, _address: str, *args) -> None:
+        target = str(args[0]) if args and args[0] != "" else None
+        self.hb.stop_all(target=target)
+
+    def _handle_ping(self, _address: str, *_args) -> None:
+        self.hb.ping()
+
+    # ── Lifecycle ───────────────────────────────────────────────────
+    def serve_forever(self) -> None:
+        """Block and relay OSC until interrupted."""
+        Dispatcher, BlockingOSCUDPServer = _require_pythonosc()
+        disp = Dispatcher()
+        disp.map("/hapbeat/play", self._handle_play)
+        disp.map("/hapbeat/stop", self._handle_stop)
+        disp.map("/hapbeat/stop-all", self._handle_stop_all)
+        disp.map("/hapbeat/ping", self._handle_ping)
+        self._server = BlockingOSCUDPServer((self.listen_host, self.listen_port), disp)
+        logger.info(
+            "OSC bridge listening on %s:%d -> UDP %d",
+            self.listen_host, self.listen_port, self.hb._client.port,
+        )
+        try:
+            self._server.serve_forever()
+        finally:
+            self._server.server_close()
+            self._server = None
+
+    def stop(self) -> None:
+        if self._server is not None:
+            self._server.shutdown()
+
+
+def run_bridge(
+    listen_port: int = DEFAULT_OSC_PORT,
+    *,
+    udp_port: int = 7700,
+    app_name: str = "hapbeat-osc",
+    event_map=None,
+) -> None:
+    """Open a Hapbeat connection and serve the OSC bridge (blocking).
+
+    Pass an ``event_map`` (e.g. ``EventMap.from_file("haptics.json")``) so OSC
+    events route command vs clip and pick up per-event targets from the haptic
+    file -- otherwise every ``/hapbeat/play`` is a plain command broadcast.
+    """
+    hb = Hapbeat(port=udp_port, app_name=app_name, event_map=event_map).open()
+    try:
+        OscBridge(hb, listen_port=listen_port).serve_forever()
+    finally:
+        hb.close()

hapbeat/protocol.py

@@ -0,0 +1,253 @@
+"""Hapbeat Layer 1 (SDK -> device) UDP protocol.
+
+Pure, dependency-free packet builders and parsers. This module is the
+*single source of truth* for the wire format inside the Python SDK and is
+the part that must stay byte-for-byte compatible with
+``hapbeat-contracts/specs/message-format.md``.
+
+Every multi-byte field is little-endian. Command packets are capped at
+512 bytes; streaming packets at MTU.
+
+The reference implementation in other languages:
+    - C#:     hapbeat-unity-sdk/Runtime/HapbeatProtocol.cs
+    - Python: hapbeat-helper/src/hapbeat_helper/protocol.py
+"""
+
+from __future__ import annotations
+
+import struct
+from typing import Optional
+
+# ── Header constants ────────────────────────────────────────────────
+MAGIC = 0x4842  # ASCII "HB"
+VERSION = 0x01
+HEADER_SIZE = 8
+MAX_PACKET_SIZE = 512          # command packets
+MAX_STREAM_PACKET_SIZE = 1472  # 1500 MTU - 20 IP - 8 UDP
+
+# App name shown on the device OLED is capped to the display grid width
+# (contracts/specs/display-layout.md, 16 chars).
+MAX_APP_NAME_LEN = 16
+
+# ── Command types (SDK -> device) ───────────────────────────────────
+CMD_PLAY = 0x01
+CMD_STOP = 0x02
+CMD_STOP_ALL = 0x03
+CMD_PING = 0x10
+CMD_CONNECT_STATUS = 0x20
+CMD_STREAM_BEGIN = 0x30
+CMD_STREAM_DATA = 0x31
+CMD_STREAM_END = 0x32
+
+# ── Response types (device -> SDK) ──────────────────────────────────
+CMD_PONG = 0x11
+CMD_ERROR = 0xFF
+
+# ── Audio formats (streaming) ───────────────────────────────────────
+AUDIO_FORMAT_PCM16 = 0
+AUDIO_FORMAT_IMA_ADPCM = 1
+
+
+# ── Header ──────────────────────────────────────────────────────────
+def build_header(command_type: int, seq: int, payload_length: int) -> bytes:
+    """Build the 8-byte common header (little-endian).
+
+    Layout: magic(u16) version(u8) command_type(u8) seq(u16) payload_length(u16)
+    """
+    return struct.pack(
+        "<HBBHH", MAGIC, VERSION, command_type, seq & 0xFFFF, payload_length
+    )
+
+
+def parse_header(data: bytes) -> Optional[dict]:
+    """Parse the common header. Returns ``None`` on bad magic/version/length."""
+    if len(data) < HEADER_SIZE:
+        return None
+    magic, version, cmd, seq, payload_len = struct.unpack(
+        "<HBBHH", data[:HEADER_SIZE]
+    )
+    if magic != MAGIC or version != VERSION:
+        return None
+    return {"command_type": cmd, "seq": seq, "payload_length": payload_len}
+
+
+def build_packet(command_type: int, seq: int, payload: bytes = b"") -> bytes:
+    """Assemble a full command packet and enforce the 512-byte cap."""
+    total = HEADER_SIZE + len(payload)
+    if total > MAX_PACKET_SIZE:
+        raise ValueError(
+            f"packet size {total} exceeds maximum {MAX_PACKET_SIZE} bytes"
+        )
+    return build_header(command_type, seq, len(payload)) + payload
+
+
+def parse_packet(data: bytes) -> Optional[tuple[int, int, bytes]]:
+    """Parse a packet into ``(command_type, seq, payload)`` or ``None``."""
+    hdr = parse_header(data)
+    if hdr is None:
+        return None
+    end = HEADER_SIZE + hdr["payload_length"]
+    if len(data) < end:
+        return None
+    return hdr["command_type"], hdr["seq"], data[HEADER_SIZE:end]
+
+
+# ── Command builders ────────────────────────────────────────────────
+def build_play(
+    seq: int,
+    event_id: str,
+    *,
+    target: str = "",
+    target_time_us: int = 0,
+    gain: float = 1.0,
+) -> bytes:
+    """PLAY (0x01).
+
+    Wire payload (see contracts/specs/device-addressing.md §5.1):
+        event_id(null-term) + target(null-term) + target_time(i64) + gain(f32)
+
+    ``target=""`` broadcasts to every device.
+    """
+    payload = (
+        event_id.encode("utf-8") + b"\x00"
+        + target.encode("utf-8") + b"\x00"
+        + struct.pack("<qf", int(target_time_us), float(gain))
+    )
+    return build_packet(CMD_PLAY, seq, payload)
+
+
+def build_stop(seq: int, event_id: str, *, target: str = "") -> bytes:
+    """STOP (0x02). Payload: event_id(null-term) + target(null-term)."""
+    payload = event_id.encode("utf-8") + b"\x00" + target.encode("utf-8") + b"\x00"
+    return build_packet(CMD_STOP, seq, payload)
+
+
+def build_stop_all(seq: int, *, target: str = "") -> bytes:
+    """STOP_ALL (0x03). Payload: target(null-term)."""
+    payload = target.encode("utf-8") + b"\x00"
+    return build_packet(CMD_STOP_ALL, seq, payload)
+
+
+def build_ping(seq: int, timestamp_us: int) -> bytes:
+    """PING (0x10). Payload: timestamp(i64, microseconds)."""
+    return build_packet(CMD_PING, seq, struct.pack("<q", int(timestamp_us)))
+
+
+def build_connect_status(
+    seq: int,
+    *,
+    connected: bool = True,
+    group: int = 0,
+    app_name: str = "",
+    device_name: str = "",
+) -> bytes:
+    """CONNECT_STATUS (0x20). Periodic keep-alive shown on the device OLED.
+
+    Wire payload matches the proven Unity layout
+    (HapbeatProtocol.cs ``BuildConnectStatusPayload``), which is what the
+    firmware actually parses:
+        connected(u8) + group(u8) + app_name(null-term) + device_name(null-term)
+    """
+    payload = (
+        bytes([1 if connected else 0, group & 0xFF])
+        + app_name.encode("utf-8") + b"\x00"
+        + device_name.encode("utf-8") + b"\x00"
+    )
+    return build_packet(CMD_CONNECT_STATUS, seq, payload)
+
+
+# ── Streaming builders (clip-mode playback) ─────────────────────────
+def build_stream_begin(
+    seq: int,
+    *,
+    sample_rate: int = 16000,
+    channels: int = 1,
+    fmt: int = AUDIO_FORMAT_PCM16,
+    total_samples: int = 0,
+    gain: float = 1.0,
+    target: str = "",
+) -> bytes:
+    """STREAM_BEGIN (0x30).
+
+    Default format is PCM16 — clip streaming sends uncompressed 16-bit PCM
+    (ADPCM is reserved but not produced by the SDK).
+    """
+    payload = struct.pack(
+        "<HBBIf", sample_rate, channels, fmt, total_samples, float(gain)
+    )
+    if target:
+        payload += target.encode("utf-8") + b"\x00"
+    return build_packet(CMD_STREAM_BEGIN, seq, payload)
+
+
+def build_stream_data(seq: int, offset: int, data: bytes) -> bytes:
+    """STREAM_DATA (0x31). Uses the larger MTU-safe size cap."""
+    payload = struct.pack("<I", offset) + data
+    total = HEADER_SIZE + len(payload)
+    if total > MAX_STREAM_PACKET_SIZE:
+        raise ValueError(
+            f"stream packet {total} exceeds MTU cap {MAX_STREAM_PACKET_SIZE}"
+        )
+    return build_header(CMD_STREAM_DATA, seq, len(payload)) + payload
+
+
+def build_stream_end(seq: int) -> bytes:
+    """STREAM_END (0x32). No payload."""
+    return build_packet(CMD_STREAM_END, seq, b"")
+
+
+# ── Response parsers ────────────────────────────────────────────────
+def _read_cstr(buf: bytes) -> tuple[str, bytes]:
+    idx = buf.find(b"\x00")
+    if idx < 0:
+        return buf.decode("utf-8", errors="replace"), b""
+    return buf[:idx].decode("utf-8", errors="replace"), buf[idx + 1:]
+
+
+def parse_pong(data: bytes) -> Optional[dict]:
+    """Parse a PONG (0x11).
+
+    Bridge form is 16 bytes (timestamp, server_time). Devices append an
+    extended form (name / address / firmware_version, plus optional
+    trailing volume bytes). Returns ``None`` if not a valid PONG.
+    """
+    hdr = parse_header(data)
+    if hdr is None or hdr["command_type"] != CMD_PONG:
+        return None
+    payload = data[HEADER_SIZE:]
+    if len(payload) < 16:
+        return None
+
+    timestamp, server_time = struct.unpack("<qq", payload[:16])
+    out: dict = {
+        "seq": hdr["seq"],
+        "timestamp": timestamp,
+        "server_time": server_time,
+    }
+    rest = payload[16:]
+    if rest:
+        out["device_name"], rest = _read_cstr(rest)
+    if rest:
+        out["address"], rest = _read_cstr(rest)
+    if rest:
+        out["firmware_version"], rest = _read_cstr(rest)
+    if len(rest) >= 1:
+        out["volume_level"] = rest[0]
+    if len(rest) >= 2:
+        out["volume_wiper"] = rest[1]
+    if len(rest) >= 3:
+        out["volume_steps"] = rest[2]
+    return out
+
+
+def parse_error(data: bytes) -> Optional[dict]:
+    """Parse an ERROR (0xFF). Payload: error_code(u16) + message(null-term)."""
+    parsed = parse_packet(data)
+    if parsed is None or parsed[0] != CMD_ERROR:
+        return None
+    payload = parsed[2]
+    if len(payload) < 2:
+        return None
+    (code,) = struct.unpack("<H", payload[:2])
+    message, _ = _read_cstr(payload[2:])
+    return {"error_code": code, "message": message}

hapbeat/wav.py

@@ -0,0 +1,51 @@
+"""Read a WAV file's PCM16 bytes for clip streaming.
+
+The device streams uncompressed 16-bit PCM (16 kHz expected, matching the
+kit-tools normalization). This thin wrapper over the stdlib :mod:`wave` module
+returns the raw interleaved PCM16-LE bytes ready to hand to STREAM_DATA, plus
+the sample rate and channel count for STREAM_BEGIN.
+"""
+
+from __future__ import annotations
+
+import wave
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Union
+
+
+@dataclass
+class WavPcm:
+    sample_rate: int
+    channels: int
+    data: bytes  # raw interleaved PCM16 little-endian (the WAV data chunk)
+
+
+def read_wav_pcm16(path: Union[str, Path]) -> WavPcm:
+    """Read an uncompressed 16-bit PCM WAV. Raises on other formats.
+
+    Non-16 kHz files are accepted but produce a warning -- the device plays at
+    16 kHz so the pitch/duration would be off; author clips at 16 kHz.
+    """
+    with wave.open(str(path), "rb") as w:
+        if w.getsampwidth() != 2:
+            raise ValueError(
+                f"WAV must be 16-bit PCM (got {w.getsampwidth() * 8}-bit): {path}"
+            )
+        if w.getcomptype() != "NONE":
+            raise ValueError(
+                f"WAV must be uncompressed PCM (got {w.getcomptype()}): {path}"
+            )
+        sample_rate = w.getframerate()
+        channels = w.getnchannels()
+        data = w.readframes(w.getnframes())
+
+    if sample_rate != 16000:
+        import warnings
+
+        warnings.warn(
+            f"WAV {path} is {sample_rate} Hz; the device expects 16000 Hz "
+            "(pitch/duration will be off). Author clips at 16 kHz.",
+            stacklevel=2,
+        )
+    return WavPcm(sample_rate=sample_rate, channels=channels, data=data)

hapbeat_python_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: hapbeat-python-sdk
+Version: 0.1.0
+Summary: Python SDK for driving Hapbeat haptic devices over Wi-Fi UDP
+Author-email: Hapbeat <yus988@hapbeat.com>
+License: MIT
+Project-URL: Homepage, https://devtools.hapbeat.com/
+Project-URL: Documentation, https://devtools.hapbeat.com/docs/sdk-integration/
+Project-URL: Repository, https://github.com/hapbeat/hapbeat-python-sdk
+Project-URL: Issues, https://github.com/hapbeat/hapbeat-python-sdk/issues
+Keywords: hapbeat,haptics,udp,osc,vr,research,psychopy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: osc
+Requires-Dist: python-osc>=1.8; extra == "osc"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# Hapbeat Python SDK
+
+Drive [Hapbeat](https://hapbeat.com) haptic devices from Python over Wi-Fi UDP.
+For researchers (PsychoPy / Jupyter / ROS), media artists, and anyone
+prototyping haptics in Python.
+
+> **📚 Docs**: <https://devtools.hapbeat.com/docs/sdk-integration/>
+
+A script can drive Hapbeat with a few lines. The fire side (`play` / `stop`)
+and the tuning side (`EventMap`) are kept orthogonal and linked only by
+event id.
+
+## Install
+
+```bash
+pip install hapbeat-python-sdk        # core (zero dependencies, stdlib socket only)
+pip install "hapbeat-python-sdk[osc]"   # + generic OSC bridge (TouchOSC / Max / TD)
+```
+
+With **pipx** you get the `hapbeat` CLI (including the launchpad below) in an
+isolated environment: `pipx install hapbeat-python-sdk`. Note that pipx does *not* make
+`import hapbeat` available to your own scripts — for the `examples/` use a
+normal `pip install` in a venv.
+
+## Try everything from one page (launchpad)
+
+```bash
+hapbeat launchpad          # opens http://127.0.0.1:7100 in your browser
+```
+
+A single local web page to fire events, run a metronome, a breathing pacer,
+or send Morse — start and stop them live, no per-example launching. It serves
+a tiny stdlib HTTP server that relays button presses to the device over UDP
+(browsers can't send UDP directly). Works great with `pipx install hapbeat-python-sdk`.
+
+## Quick start
+
+```python
+import hapbeat
+
+hb = hapbeat.connect(app_name="MyExperiment")  # opens UDP broadcast + keep-alive
+hb.play("impact.hit", gain=0.3)   # fire event "impact.hit" at gain 0.3
+hb.play("impact.hit")             # gain omitted -> kit baseline intensity
+hb.stop("impact.hit")
+hb.stop_all()
+hb.close()
+```
+
+or as a context manager:
+
+```python
+with hapbeat.connect(app_name="MyExperiment") as hb:
+    hb.play("impact.hit")
+```
+
+`"impact.hit"` must be an event id present in the **kit deployed to the
+device** (via [Hapbeat Studio](https://devtools.hapbeat.com)). The SDK sends
+the *instruction*; the waveform lives in the kit on the device.
+
+## Discovery
+
+```python
+for dev in hb.discover(timeout=1.5):
+    print(dev.ip, dev.address, dev.firmware_version)
+```
+
+## EventMap — the tuning side (optional)
+
+Keep per-event default gains in one place and let `play("id")` resolve them,
+so firing code never hard-codes intensities:
+
+```python
+em = hapbeat.EventMap.from_manifest("my-kit/my-kit-manifest.json")
+hb = hapbeat.connect(event_map=em)
+hb.play("impact.hit")        # uses the kit manifest's intensity for this event
+```
+
+`EventMap` reads the kit manifest (schema 2.0.0) `intensity` as the baseline
+gain. You can also build one by hand: `EventMap.from_dict({"impact.hit": 0.5})`.
+
+### Haptic file — add targeting on top of the kit
+
+The Studio-generated manifest holds kit content (intensity / clip), but not
+app-side concerns like **which device/body part** an event goes to. Put those
+in a *haptic file* (an EventMap overlay that references the kit), so `play(id)`
+resolves the target without the caller passing it:
+
+```json
+// haptics.json
+{
+  "kit": "kits/my-kit",
+  "events": {
+    "impact.hit": { "target": "player_1/chest", "gain": 0.8 },
+    "rain.loop":  { "target": "*/back" }
+  }
+}
+```
+
+```python
+hb = hapbeat.connect(app_name="MyApp", haptics="haptics.json")
+hb.play("impact.hit")     # goes to player_1/chest at gain 0.8 — from the file
+```
+
+## Two playback modes: command and clip
+
+The same `play(id)` call branches on the manifest:
+
+| Manifest bucket | Mode | What happens |
+|---|---|---|
+| `events` | **command** | the SDK sends a PLAY; the **device** plays its installed clip |
+| `stream_events` | **clip** | the SDK reads the WAV from the kit's `stream-clips/` and **streams** it over UDP |
+
+Put the kit inside your project and call events by id — the per-event details
+(intensity, loop, command vs clip, which WAV) live in the kit, not your code:
+
+```
+my-app/
+  app.py
+  kits/my-kit/
+    my-kit-manifest.json     # the "haptic file" -> EventMap
+    install-clips/           # command clips (flashed to the device via Studio)
+    stream-clips/*.wav       # clip-mode WAVs the SDK streams
+```
+
+```python
+import hapbeat
+hb = hapbeat.connect(app_name="MyApp", kit="kits/my-kit")
+hb.play("impact.hit")     # command -> device plays its installed clip
+hb.play("rain.loop")      # clip    -> SDK streams stream-clips/<wav> over UDP
+hb.stop("rain.loop")      # ends the active stream
+```
+
+You can also stream an ad-hoc PCM16 buffer (e.g. a synthesized stereo cue where
+L/R amplitude conveys direction):
+
+```python
+hb.stream_pcm(pcm_bytes, sample_rate=16000, channels=2)
+```
+
+Author clips as **16 kHz mono PCM16** (the device plays at 16 kHz; the SDK does
+not resample). A full runnable example is in
+[examples/clip_project/](examples/clip_project/).
+
+## Generic OSC bridge
+
+Any OSC tool (TouchOSC, Max/MSP, TouchDesigner, a DAW) can drive Hapbeat
+without code. Run the bridge and send `/hapbeat/play <event_id> [target] [time] [gain]`:
+
+```bash
+hapbeat osc-bridge --listen 7702
+```
+
+See [docs/osc.md](docs/osc.md) for the address spec.
+
+## CLI
+
+```bash
+hapbeat scan                       # list devices on the LAN
+hapbeat play impact.hit --gain 0.3
+hapbeat stop-all
+hapbeat launchpad                  # browser UI for all of the above
+```
+
+## Examples
+
+Ready-to-run sample applications live in [examples/](examples/):
+a psychophysics experiment, a breathing pacer, a haptic metronome,
+a live trigger pad, a task-completion notifier, and a Morse transmitter.
+Each is a single stdlib-only file — see [examples/README.md](examples/README.md).
+
+## For AI coding agents
+
+Working with Claude / Cursor / Copilot? Hand your agent [AGENTS.md](AGENTS.md) —
+a single self-contained file with the SDK's model, API, project layout, and
+pitfalls. One file is enough to get the whole picture.
+
+> Use the Hapbeat Python SDK. Read `AGENTS.md` and follow its API and best practices.
+
+## License
+
+MIT © Hapbeat

hapbeat_python_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+hapbeat/__init__.py,sha256=6FABLnQeXm1nxqiiGLQWyDko1h5Nhr3RuF-vYEBW8n0,1268
+hapbeat/__main__.py,sha256=ji2N-J5BX8XSUrihVzwQuttefiOYsu3pTzuYAsgMIUU,120
+hapbeat/cli.py,sha256=FMCggde6NeWMNXbw5v939dQQ1X0kkY0HUno8TA5L3YE,4624
+hapbeat/client.py,sha256=MGwTbtn6j4uAw0pDLWBDDuOi_u5nyWT3k1IiWu67TPo,5995
+hapbeat/clip.py,sha256=PpVPht61HWiHolLkpCFBXdL7d_3syraaaJUwgF_2J0o,4892
+hapbeat/eventmap.py,sha256=odDRXGt2CmcQsMed7NHlz0pbmQLRqxjti2T9uXxsyCg,8386
+hapbeat/hapbeat.py,sha256=IqNIrKp2j17y4QLse80Wb98BSTGLJ7wGBtDKuUmdgVM,16858
+hapbeat/launchpad.py,sha256=wvnIFLtrux_PzdR7TrsCqIhtOLhLJzXuOdfam7e2tQ4,26792
+hapbeat/osc.py,sha256=cD0_QA6M1Km7VhXvPGYLHyWFj_V5uUQAfPG1myYvYxw,4589
+hapbeat/protocol.py,sha256=WNjjgxO_RP25WF2qZDtC_p_69lUyJ9WGjAMn77i6ITY,8928
+hapbeat/wav.py,sha256=zAxCWLEliCclFhiOtWlgfqra3Eua89VfwsDOCFtk3lY,1716
+hapbeat_python_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=iaWGp90FSWArzrtS2s0C-hGqRlguPdFt8vxkPT4SEj8,1064
+hapbeat_python_sdk-0.1.0.dist-info/METADATA,sha256=3lBi5pbXGtVQdl0P2ca6FwM8G2LbWcvolv1dmtCeFhY,7278
+hapbeat_python_sdk-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+hapbeat_python_sdk-0.1.0.dist-info/entry_points.txt,sha256=6GpFtyk5e9Kh3Y_lDOGPp1jQqYL5eiCK9kbz08cdiek,45
+hapbeat_python_sdk-0.1.0.dist-info/top_level.txt,sha256=FLePhbdKs48thuuow2Z1_X_3V-2oxhDdeOX_bu5to8M,8
+hapbeat_python_sdk-0.1.0.dist-info/RECORD,,

hapbeat_python_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hapbeat_python_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hapbeat = hapbeat.cli:main