wildtrax-client 0.1.0__py3-none-any.whl

wildtrax_client/__init__.py

@@ -0,0 +1,30 @@
+"""wildtrax-client -- Python client for the WildTrax 2027 HTTP /api control surface."""
+
+from .client import WildTrax, DEFAULT_PORT
+from .errors import (
+    WildTraxError,
+    ConnectionFailed,
+    PendingApprovalError,
+    PermissionDenied,
+    NotFound,
+    RecordingInProgress,
+    RateLimited,
+    BadRequest,
+    ServerError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "WildTrax",
+    "DEFAULT_PORT",
+    "WildTraxError",
+    "ConnectionFailed",
+    "PendingApprovalError",
+    "PermissionDenied",
+    "NotFound",
+    "RecordingInProgress",
+    "RateLimited",
+    "BadRequest",
+    "ServerError",
+]

wildtrax_client/client.py

@@ -0,0 +1,475 @@
+"""WildTrax 2027 HTTP /api client.
+
+A thin, dependency-free (stdlib urllib) client for the WildTrax desktop server's
+HTTP control surface. Mirrors the same actions the OSC protocol exposes -- two
+transports, one capability set.
+
+    from wildtrax_client import WildTrax
+
+    wt = WildTrax("192.168.1.155")        # default port 5659
+    wt.wait_for_approval()                  # block until host approves this device
+    wt.transport.record()
+    wt.tracks.mute(1, True)                  # mute Track 1 (indices are 1-based)
+    wt.metadata.scene("SC07")
+    print(wt.session_state())
+
+Indices are 1-BASED. Every index argument (track index, pad index, row index,
+file index, matrix row/col, ...) is 1-based, matching the WildTrax UI (Track 1,
+Input 1) and the OSC surface -- so `wt.tracks.mute(1)` mutes the first track, the
+one shown as "Track 1". The server converts 1-based -> 0-based internally at the
+HTTP seam; pass what the UI shows. (This is the v27 convention across both the
+HTTP and OSC public surfaces; the desktop's internal models remain 0-based.)
+
+Approval model: the first request from a new device lands in the desktop Session
+Manager as *pending* and returns 202. A human approves it once (and grants Write
+for write actions). Until then, calls raise PendingApprovalError; use
+wait_for_approval() to poll, or catch the exception.
+"""
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from . import errors
+
+DEFAULT_PORT = 5659
+DEFAULT_TIMEOUT = 5.0
+
+
+class WildTrax:
+    """Connection to one WildTrax server's HTTP /api surface."""
+
+    def __init__(self, host, port=DEFAULT_PORT, timeout=DEFAULT_TIMEOUT):
+        self.base_url = "http://{}:{}".format(host, port)
+        self.timeout = timeout
+        # Namespaced action groups (mirror the /api route groups).
+        self.transport = _Transport(self)
+        self.tracks = _Tracks(self)
+        self.metadata = _Metadata(self)
+        self.config = _Config(self)
+        self.soundboard = _Soundboard(self)
+        self.playlist = _Playlist(self)
+        self.export = _ExportFiles(self)
+        self.report = _SoundReport(self)
+
+    # ---- transport -------------------------------------------------------
+
+    def _request(self, method, route, body=None):
+        """Issue an HTTP request. Returns parsed JSON (dict) or {} for empty
+        bodies. Raises the mapped WildTraxError on a non-2xx status."""
+        url = self.base_url + route
+        data = None
+        headers = {}
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return self._parse(resp.status, resp.read())
+        except urllib.error.HTTPError as e:
+            # urllib raises on 4xx/5xx; the body still carries our JSON error.
+            return self._parse(e.code, e.read())
+        except urllib.error.URLError as e:
+            raise errors.ConnectionFailed(
+                "could not reach {}: {}".format(url, e.reason)
+            )
+
+    def _parse(self, status, raw):
+        try:
+            payload = json.loads(raw) if raw else {}
+        except (ValueError, TypeError):
+            payload = {}
+
+        # 202 is "accepted but not approved yet" -- urllib treats it as success
+        # (no HTTPError), so it must be intercepted here before the 2xx return.
+        if status == 202:
+            raise errors.PendingApprovalError(
+                "device awaiting approval in WildTrax Session Manager"
+            )
+        if 200 <= status < 300:
+            return payload
+
+        msg = payload.get("error") or payload.get("message") or "HTTP {}".format(status)
+        if status == 400:
+            raise errors.BadRequest(msg)
+        if status == 403:
+            raise errors.PermissionDenied(msg)
+        if status == 404:
+            raise errors.NotFound(msg)
+        if status == 409:
+            raise errors.RecordingInProgress(msg)
+        if status == 429:
+            raise errors.RateLimited(msg)
+        raise errors.ServerError("{} ({})".format(msg, status))
+
+    def _get(self, route):
+        return self._request("GET", route)
+
+    def _post(self, route, **body):
+        # Drop None values so optional fields are omitted, not sent as null.
+        clean = {k: v for k, v in body.items() if v is not None}
+        return self._request("POST", route, clean or None)
+
+    # ---- discovery / approval -------------------------------------------
+
+    def hello(self):
+        """GET /api/hello -- {app, version, status}. Registers this device as a
+        pending client if it isn't known yet. Does not raise on pending."""
+        return self._get("/api/hello")
+
+    def is_approved(self):
+        """True once the host has approved this device."""
+        status = self.hello().get("status", "")
+        return status.startswith("approved")
+
+    def can_write(self):
+        """True once approved AND granted Write permission."""
+        return self.hello().get("status") == "approved"
+
+    def wait_for_approval(self, timeout=120.0, poll_interval=1.0):
+        """Block until the host approves this device in Session Manager, or
+        raise PendingApprovalError after `timeout` seconds. Returns the hello
+        payload once approved."""
+        deadline = time.monotonic() + timeout
+        while True:
+            info = self.hello()
+            if str(info.get("status", "")).startswith("approved"):
+                return info
+            if time.monotonic() >= deadline:
+                raise errors.PendingApprovalError(
+                    "still pending after {:.0f}s -- approve this device in the "
+                    "WildTrax Session Manager".format(timeout)
+                )
+            time.sleep(poll_interval)
+
+    # ---- readback --------------------------------------------------------
+
+    def session_state(self):
+        """GET /api/session/state -- the full session snapshot."""
+        return self._get("/api/session/state")
+
+    def recording(self):
+        """GET /api/record/state -- {recording: bool}."""
+        return self._get("/api/record/state").get("recording", False)
+
+    def get_tracks(self):
+        return self._get("/api/tracks").get("tracks")
+
+    def get_metadata(self):
+        return self._get("/api/metadata")
+
+    # ---- per-element readback (HTTP mirror of the OSC flat read-side) -----
+    # All indices are 1-BASED (== the WildTrax UI and the OSC surface).
+
+    def get_pad(self, pad_index):
+        """GET /api/soundboard/<i> -- one soundboard pad's JSON (1-based)."""
+        return self._get(f"/api/soundboard/{pad_index}")
+
+    def get_playlist_row(self, row_index):
+        """GET /api/playlist/<i> -- one playlist row's JSON (1-based)."""
+        return self._get(f"/api/playlist/{row_index}")
+
+    def get_export_file(self, file_index):
+        """GET /api/exportfiles/<i> -- one export file's JSON (1-based)."""
+        return self._get(f"/api/exportfiles/{file_index}")
+
+    def get_matrix(self, which):
+        """GET /api/matrix/<which> -- full input/output matrix snapshot."""
+        return self._get(f"/api/matrix/{which}")
+
+    def get_soundreport_entry(self, row_index):
+        """GET /api/soundreport/<i> -- one sound-report entry's JSON (1-based)."""
+        return self._get(f"/api/soundreport/{row_index}")
+
+    def get_session_client(self, client_index):
+        """GET /api/session/clients/<i> -- one client record's JSON (1-based)."""
+        return self._get(f"/api/session/clients/{client_index}")
+
+
+# --------------------------------------------------------------------------
+# Namespaced action groups. Each mirrors the matching /api/<group>/* routes and
+# the JSON body the server expects (same field names as the OSC command dicts).
+# --------------------------------------------------------------------------
+
+
+class _Group:
+    def __init__(self, client):
+        self._c = client
+
+
+class _Transport(_Group):
+    def record(self):
+        """Start recording / advance take (server decides based on state)."""
+        return self._c._post("/api/record/start")
+
+    def stop(self):
+        return self._c._post("/api/record/stop")
+
+    def false_start(self):
+        """Request a false start (the desktop confirms)."""
+        return self._c._post("/api/record/falsestart")
+
+    def false_start_confirmed(self):
+        """Pre-authorized false start (skip desktop confirmation)."""
+        return self._c._post("/api/record/falsestart/confirmed")
+
+
+class _Tracks(_Group):
+    def arm(self, index, value=True):
+        return self._c._post("/api/track/arm", trackIndex=index, value=value)
+
+    def mute(self, index, value=True):
+        return self._c._post("/api/track/mute", trackIndex=index, value=value)
+
+    def monitor(self, index, value=True):
+        return self._c._post("/api/track/monitor", trackIndex=index, value=value)
+
+    def pan(self, index, pan):
+        """pan: 0=Left, 1=Right, 2=Center (desktop PanState values)."""
+        return self._c._post("/api/track/pan", trackIndex=index, pan=pan)
+
+    def name(self, index, name):
+        return self._c._post("/api/track/name", trackIndex=index, name=name)
+
+    def add(self):
+        return self._c._post("/api/track/add")
+
+    def remove(self, index):
+        return self._c._post("/api/track/remove", trackIndex=index)
+
+    def set_count(self, count):
+        return self._c._post("/api/track/count", count=count)
+
+
+class _Metadata(_Group):
+    def project(self, value):
+        return self._c._post("/api/metadata/project", value=value)
+
+    def scene(self, value):
+        return self._c._post("/api/metadata/scene", value=value)
+
+    def slate(self, value):
+        return self._c._post("/api/metadata/slate", value=value)
+
+    def take(self, value):
+        return self._c._post("/api/metadata/take", value=value)
+
+    def roll(self, value):
+        return self._c._post("/api/metadata/roll", value=value)
+
+    def note(self, value):
+        return self._c._post("/api/metadata/note", value=value)
+
+    def add_marker(self):
+        return self._c._post("/api/metadata/marker/add")
+
+    def add_note_to_bank(self, note):
+        return self._c._post("/api/metadata/notebank/add", note=note)
+
+    def remove_note_from_bank(self, index):
+        return self._c._post("/api/metadata/notebank/remove", index=index)
+
+    def insert_quick_note(self, note_index):
+        return self._c._post("/api/metadata/notebank/insert", noteIndex=note_index)
+
+    # next-take template
+    def next_project(self, value):
+        return self._c._post("/api/metadata/next/project", value=value)
+
+    def next_scene(self, value):
+        return self._c._post("/api/metadata/next/scene", value=value)
+
+    def next_slate(self, value):
+        return self._c._post("/api/metadata/next/slate", value=value)
+
+    def next_take(self, value):
+        return self._c._post("/api/metadata/next/take", value=value)
+
+    def next_roll(self, value):
+        return self._c._post("/api/metadata/next/roll", value=value)
+
+    def reset_next(self):
+        return self._c._post("/api/metadata/next/reset")
+
+    # auto-increment / auto-reset flags
+    def auto_increment(self, field, value):
+        """field: 'slate' | 'take' | 'roll'."""
+        return self._c._post("/api/metadata/autoincrement/" + field, value=value)
+
+    def auto_reset(self, field, value):
+        """field: 'slate' | 'take' | 'roll' -- reset on scene change."""
+        return self._c._post("/api/metadata/autoreset/" + field, value=value)
+
+
+class _Config(_Group):
+    def preroll(self, enabled):
+        return self._c._post("/api/config/preroll", value=enabled)
+
+    def preroll_full(self, enabled, size_seconds):
+        return self._c._post(
+            "/api/config/preroll/full", prerollEnabled=enabled, prerollSize=size_seconds
+        )
+
+    def meter_smoothness(self, value):
+        """value: 0.0 .. 1.0."""
+        return self._c._post("/api/config/smoothness", value=value)
+
+    def global_monitor(self, enabled):
+        return self._c._post("/api/config/monitor", value=enabled)
+
+    def playback_volume(self, value):
+        """value: 0 .. 100."""
+        return self._c._post("/api/playback/volume", value=value)
+
+    def matrix_cell(self, matrix, row, col, value=True):
+        """matrix: 'input' | 'output'. Rejected while recording."""
+        return self._c._post("/api/matrix/cell", matrix=matrix, row=row, col=col, value=value)
+
+
+class _Soundboard(_Group):
+    def play(self, pad_index):
+        return self._c._post("/api/soundboard/play", padIndex=pad_index)
+
+    def stop(self, pad_index):
+        return self._c._post("/api/soundboard/stop", padIndex=pad_index)
+
+    def add_pad(self):
+        return self._c._post("/api/soundboard/pad/add")
+
+    def remove_pad(self, pad_index):
+        return self._c._post("/api/soundboard/pad/remove", padIndex=pad_index)
+
+    def move_pad(self, from_index, to_index):
+        return self._c._post(
+            "/api/soundboard/pad/move", fromIndex=from_index, toIndex=to_index
+        )
+
+    def title(self, pad_index, title):
+        return self._c._post("/api/soundboard/pad/title", padIndex=pad_index, title=title)
+
+    def color(self, pad_index, color):
+        return self._c._post("/api/soundboard/pad/color", padIndex=pad_index, color=color)
+
+    def fade_in(self, pad_index, value=True):
+        return self._c._post("/api/soundboard/pad/fadein", padIndex=pad_index, value=value)
+
+    def repeat(self, pad_index, value=True):
+        return self._c._post("/api/soundboard/pad/repeat", padIndex=pad_index, value=value)
+
+    def solo(self, pad_index, value=True):
+        return self._c._post("/api/soundboard/pad/solo", padIndex=pad_index, value=value)
+
+    def fade_out(self, pad_index, value=True):
+        return self._c._post("/api/soundboard/pad/fadeout", padIndex=pad_index, value=value)
+
+    def trigger_mode(self, pad_index, mode):
+        return self._c._post(
+            "/api/soundboard/pad/triggermode", padIndex=pad_index, triggerMode=mode
+        )
+
+    def routing_mode(self, pad_index, mode):
+        """mode: 0 auto, 1 stereo, 2 mono left, 3 mono right, 4 mono center, 5 custom."""
+        return self._c._post(
+            "/api/soundboard/pad/routingmode", padIndex=pad_index, routingMode=mode
+        )
+
+    def routing_init(self, pad_index):
+        return self._c._post("/api/soundboard/pad/routing/init", padIndex=pad_index)
+
+    def routing_cell(self, pad_index, src_channel, dst_channel, gain):
+        return self._c._post(
+            "/api/soundboard/pad/routing/cell", padIndex=pad_index,
+            srcChannel=src_channel, dstChannel=dst_channel, value=gain,
+        )
+
+
+class _Playlist(_Group):
+    def play(self):
+        return self._c._post("/api/playlist/play")
+
+    def stop(self):
+        return self._c._post("/api/playlist/stop")
+
+    def loop(self, value=True):
+        return self._c._post("/api/playlist/loop", value=value)
+
+    def index(self, index):
+        return self._c._post("/api/playlist/index", index=index)
+
+    def add_row(self):
+        return self._c._post("/api/playlist/row/add")
+
+    def remove_row(self, row_index):
+        return self._c._post("/api/playlist/row/remove", rowIndex=row_index)
+
+    def move_row(self, from_index, to_index):
+        return self._c._post(
+            "/api/playlist/row/move", fromIndex=from_index, toIndex=to_index
+        )
+
+    def row_title(self, row_index, title):
+        return self._c._post("/api/playlist/row/title", rowIndex=row_index, title=title)
+
+    def row_color(self, row_index, color):
+        return self._c._post("/api/playlist/row/color", rowIndex=row_index, color=color)
+
+    def row_routing_mode(self, row_index, mode):
+        """mode: 0 auto, 1 stereo, 2 mono left, 3 mono right, 4 mono center, 5 custom."""
+        return self._c._post(
+            "/api/playlist/row/routingmode", rowIndex=row_index, routingMode=mode
+        )
+
+    def row_routing_init(self, row_index):
+        return self._c._post("/api/playlist/row/routing/init", rowIndex=row_index)
+
+    def row_routing_cell(self, row_index, src_channel, dst_channel, gain):
+        return self._c._post(
+            "/api/playlist/row/routing/cell", rowIndex=row_index,
+            srcChannel=src_channel, dstChannel=dst_channel, value=gain,
+        )
+
+
+class _ExportFiles(_Group):
+    def add(self):
+        return self._c._post("/api/exportfiles/add")
+
+    def remove(self, file_index):
+        return self._c._post("/api/exportfiles/remove", fileIndex=file_index)
+
+    def toggle_track(self, file_index, track_index):
+        return self._c._post(
+            "/api/exportfiles/track/toggle", fileIndex=file_index, trackIndex=track_index
+        )
+
+    def display_resolved_names(self, value):
+        return self._c._post("/api/exportfiles/resolvednames", value=value)
+
+    def update(self, file_index, field, value):
+        """field: 'name' | 'folder' | 'fileFormat' | 'trackExportType' | 'selectAllTracks'."""
+        return self._c._post(
+            "/api/exportfiles/update", fileIndex=file_index, field=field, value=value
+        )
+
+
+class _SoundReport(_Group):
+    def csv(self, folder=None):
+        """GET the sound report as CSV. Returns {folder, csv}."""
+        route = "/api/soundreport/csv"
+        if folder:
+            route += "?folder=" + urllib.parse.quote(folder)
+        return self._c._get(route)
+
+    def auto_save(self, value):
+        return self._c._post("/api/soundreport/autosave", value=value)
+
+    def edit_entry(self, row, field, value, track_index=None):
+        """field: 'timecode' | 'circled' | 'note' | 'project' | 'scene' | 'slate' |
+        'take' | 'roll' | 'fps' | 'trackName' (trackName also needs track_index)."""
+        return self._c._post(
+            "/api/soundreport/entry", row=row, field=field, value=value,
+            trackIndex=track_index,
+        )

wildtrax_client/errors.py

@@ -0,0 +1,40 @@
+"""Exceptions for the WildTrax /api client, mapped from HTTP status codes."""
+
+
+class WildTraxError(Exception):
+    """Base class for all client errors."""
+
+
+class ConnectionFailed(WildTraxError):
+    """Could not reach the server (host down, refused, timeout)."""
+
+
+class PendingApprovalError(WildTraxError):
+    """The server returned 202 -- this client/IP is awaiting approval in the
+    desktop Session Manager. Approve it (and grant Write for write actions),
+    then retry. ``WildTrax.wait_for_approval()`` polls until this clears."""
+
+
+class PermissionDenied(WildTraxError):
+    """403 -- the client is approved but lacks Write permission for this action."""
+
+
+class NotFound(WildTraxError):
+    """404 -- unknown route, or a bad index (e.g. trackIndex out of range)."""
+
+
+class RecordingInProgress(WildTraxError):
+    """409 -- the action is blocked while the server is recording (e.g. arming
+    a track, changing track count, editing routing)."""
+
+
+class RateLimited(WildTraxError):
+    """429 -- transport command debounced; sent too quickly after the last one."""
+
+
+class BadRequest(WildTraxError):
+    """400 -- malformed request body (invalid JSON)."""
+
+
+class ServerError(WildTraxError):
+    """An unexpected status code from the server."""

wildtrax_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: wildtrax-client
+Version: 0.1.0
+Summary: Python client for the WildTrax 2027 HTTP /api control surface
+Author: Halter Technical
+License-Expression: MIT
+Project-URL: Homepage, https://wildtrax.io
+Project-URL: Documentation, https://wildtrax.io/resources/python-client
+Keywords: wildtrax,audio,recording,remote,osc,control
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PyWildTrax
+
+A small, dependency-free Python client for the **WildTrax 2027** HTTP `/api`
+control surface. Drive recording, tracks, metadata, the soundboard, the playlist,
+and more from scripts — the same actions the OSC protocol exposes, over plain HTTP.
+
+Built on the Python standard library only (`urllib`) — no `requests`, no extra
+installs, works anywhere Python 3.8+ runs.
+
+## Install
+
+```bash
+pip install wildtrax-client
+# or, from a checkout:
+pip install -e .
+```
+
+> Install as **`wildtrax-client`**, import as **`wildtrax_client`**:
+> ```python
+> from wildtrax_client import WildTrax
+> ```
+
+## Quick start
+
+```python
+from wildtrax_client import WildTrax
+
+wt = WildTrax("192.168.1.155")      # default HTTP port 5659
+wt.wait_for_approval()              # blocks until the host approves this device
+
+wt.metadata.scene("SC07")
+wt.transport.record()
+# ...
+wt.transport.stop()
+
+print(wt.session_state())
+```
+
+## Approval model
+
+WildTrax has no passwords — security is the host approving devices on the LAN.
+The **first** request from a new device shows up as *pending* in the desktop
+**Session Manager** and the client gets `202`. A human approves it once (and grants
+**Write** for write actions like recording). After that, the device is remembered.
+
+- `wt.wait_for_approval(timeout=120)` — poll until approved, or raise.
+- Or catch `PendingApprovalError` yourself and retry.
+- `wt.is_approved()` / `wt.can_write()` — check status without blocking.
+
+The server must have a **fixed HTTP port** enabled (Session Manager → Advanced →
+*Fixed network ports*) so the port is stable; otherwise it binds an ephemeral one.
+
+## API
+
+Methods are grouped to mirror the `/api` route families:
+
+| Namespace | Examples |
+|---|---|
+| `wt.transport` | `record()`, `stop()`, `false_start()` |
+| `wt.tracks` | `arm(i)`, `mute(i, True)`, `pan(i, 2)`, `name(i, "Boom")`, `add()`, `remove(i)`, `set_count(n)` |
+| `wt.metadata` | `scene("SC07")`, `take("T001")`, `note(...)`, `add_marker()`, `next_scene(...)`, `reset_next()`, `auto_increment("take", True)` |
+| `wt.config` | `preroll(True)`, `meter_smoothness(0.5)`, `global_monitor(True)`, `playback_volume(80)`, `matrix_cell("input", 1, 1)` |
+| `wt.soundboard` | `play(1)`, `stop(1)`, `add_pad()`, `title(1, "FX")`, `repeat(1, True)`, `trigger_mode(1, 1)`, `routing_mode(1, 5)`, `routing_cell(1, 1, 2, 1.0)` |
+| `wt.playlist` | `play()`, `stop()`, `loop(True)`, `index(2)`, `add_row()`, `row_title(1, "Cue")`, `row_routing_mode(1, 0)` |
+| `wt.export` | `add()`, `remove(i)`, `update(i, "name", "Mix")`, `toggle_track(f, t)` |
+| `wt.report` | `csv()`, `auto_save(True)`, `edit_entry(3, "circled", True)` |
+
+> **Indices are 1-based.** Every index argument (`i`, pad index, row index, file
+> index) is 1-based, matching the WildTrax UI (Track 1, Input 1) and the OSC
+> surface — `wt.tracks.mute(1)` mutes the track shown as "Track 1". The server
+> converts to its 0-based models at the HTTP seam.
+
+Readback: `wt.session_state()`, `wt.recording()`, `wt.get_tracks()`,
+`wt.get_metadata()`, `wt.report.csv()`. Per-element reads (1-based, mirror the OSC
+flat read-side): `wt.get_pad(i)`, `wt.get_playlist_row(i)`, `wt.get_export_file(i)`,
+`wt.get_matrix(which)`, `wt.get_soundreport_entry(i)`, `wt.get_session_client(i)`.
+
+> **Session administration** (approving/kicking clients, permissions, renaming the
+> session) is **not** available remotely — it's reserved for the desktop host.
+
+## Errors
+
+All raise subclasses of `WildTraxError`:
+
+| Exception | Meaning (HTTP) |
+|---|---|
+| `ConnectionFailed` | host unreachable |
+| `PendingApprovalError` | `202` — awaiting approval |
+| `PermissionDenied` | `403` — approved but no Write |
+| `NotFound` | `404` — bad route or index |
+| `RecordingInProgress` | `409` — blocked while recording |
+| `RateLimited` | `429` — transport command debounced |
+| `BadRequest` | `400` — malformed body |
+
+## License
+
+MIT

wildtrax_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+wildtrax_client/__init__.py,sha256=al0iar9r6T9rBUA5Gsp3Uixe18xj9Sl0ikqSUdRCpHg,604
+wildtrax_client/client.py,sha256=RfjP5Gi9lG05icydFtLj6Zx_8tPuMp39l3DQ2k4qsQc,17942
+wildtrax_client/errors.py,sha256=KyHsEjMKUnjr6lA5dPdzaxjlMDIqAv8DraYUGF5RsMQ,1256
+wildtrax_client-0.1.0.dist-info/licenses/LICENSE,sha256=FLBuiRlnxhLUv1a6jVh81kMGCXsRcoRW5GjbJxlAIR8,1073
+wildtrax_client-0.1.0.dist-info/METADATA,sha256=gW6LTXjxi0LAB_KBhcdpSLzcqBPEmdb5KlMAm02lU9Q,4508
+wildtrax_client-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+wildtrax_client-0.1.0.dist-info/top_level.txt,sha256=TJGlIN_ZAnVL6IKJ1fV4umQ-_Yh_eyV4V1E2WwpAkQw,16
+wildtrax_client-0.1.0.dist-info/RECORD,,

wildtrax_client-0.1.0.dist-info/WHEEL

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

wildtrax_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Halter Technical
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wildtrax_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wildtrax_client