python-mister-fpga 0.1.0__py3-none-any.whl

mister_fpga/__init__.py

@@ -0,0 +1,20 @@
+"""Async Python client for the MiSTer FPGA mrext Remote API."""
+from .client import MisterClient, MisterConnectionError, MisterStatus
+from .const import DEFAULT_PORT, INI_VIDEO_KEYS, KEYBOARD_NAMES, WS_PATH
+from .ssh import MisterSSH, parse_ssh_probe
+from .websocket import MisterWebSocketClient, apply_ws_message
+
+__all__ = [
+    "MisterClient",
+    "MisterStatus",
+    "MisterConnectionError",
+    "MisterWebSocketClient",
+    "apply_ws_message",
+    "MisterSSH",
+    "parse_ssh_probe",
+    "KEYBOARD_NAMES",
+    "INI_VIDEO_KEYS",
+    "WS_PATH",
+    "DEFAULT_PORT",
+]
+__version__ = "0.1.0"

mister_fpga/client.py

@@ -0,0 +1,292 @@
+"""Async REST client for the MiSTer FPGA mrext Remote API."""
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+import aiohttp
+
+from .const import (
+    PATH_CORE_MENU,
+    PATH_GAMES_INDEX,
+    PATH_GAMES_LAUNCH,
+    PATH_GAMES_SEARCH,
+    PATH_INIS,
+    PATH_KEYBOARD,
+    PATH_KEYBOARD_RAW,
+    PATH_LAUNCH,
+    PATH_LAUNCH_MENU,
+    PATH_LAUNCH_NEW,
+    PATH_LAUNCH_TOKEN,
+    PATH_MUSIC_NEXT,
+    PATH_MUSIC_PLAY,
+    PATH_MUSIC_PLAYBACK,
+    PATH_MUSIC_PLAYLIST,
+    PATH_MUSIC_STATUS,
+    PATH_MUSIC_STOP,
+    PATH_PEERS,
+    PATH_PLAYING,
+    PATH_REBOOT,
+    PATH_RESTART_REMOTE,
+    PATH_SCREENSHOTS,
+    PATH_SCRIPTS_CONSOLE,
+    PATH_SCRIPTS_KILL,
+    PATH_SCRIPTS_LAUNCH,
+    PATH_SCRIPTS_LIST,
+    PATH_SYSINFO,
+    PATH_SYSTEMS,
+    PATH_WALLPAPERS,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MisterConnectionError(Exception):
+    """Raised when the MiSTer Remote API is unreachable or returns an error."""
+
+
+@dataclass
+class MisterStatus:
+    """Snapshot of the MiSTer device state."""
+
+    online: bool = False
+    core: str | None = None
+    system: str | None = None
+    system_name: str | None = None
+    game: str | None = None
+    game_name: str | None = None
+    hostname: str | None = None
+    version: str | None = None
+    ip: str | None = None
+    ips: list[str] = field(default_factory=list)
+    updated: str | None = None
+    dns: str | None = None
+    disk_total: int | None = None
+    disk_used: int | None = None
+    disk_free: int | None = None
+
+    @property
+    def is_running_game(self) -> bool:
+        """True when a real core/game (not the menu) is running."""
+        if not self.online:
+            return False
+        core = (self.core or "").strip().lower()
+        return bool(core) and core not in ("menu", "none")
+
+
+class MisterClient:
+    """Thin async wrapper around the mrext Remote REST API."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 8182,
+        *,
+        session: aiohttp.ClientSession | None = None,
+        timeout: int = 10,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.base_url = f"http://{host}:{port}/api"
+        self._timeout = timeout
+        self._session = session
+        self._owns_session = session is None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def async_close(self) -> None:
+        """Close the session only if this client created it."""
+        if self._owns_session and self._session is not None:
+            await self._session.close()
+            self._session = None
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        payload: dict | None = None,
+        parse_json: bool = True,
+    ) -> Any:
+        session = await self._get_session()
+        url = f"{self.base_url}{path}"
+        try:
+            async with session.request(
+                method,
+                url,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=self._timeout),
+            ) as resp:
+                resp.raise_for_status()
+                if not parse_json:
+                    return await resp.read()
+                text = await resp.text()
+                if not text.strip():
+                    return None
+                try:
+                    return json.loads(text)
+                except json.JSONDecodeError as err:
+                    raise MisterConnectionError(
+                        f"{method} {url} returned invalid JSON: {err}"
+                    ) from err
+        except (TimeoutError, aiohttp.ClientError) as err:
+            _LOGGER.debug("Request %s %s failed: %s", method, url, err)
+            raise MisterConnectionError(f"{method} {url} failed: {err}") from err
+
+    async def async_get_status(self) -> MisterStatus:
+        sysinfo = await self._request("GET", PATH_SYSINFO) or {}
+        playing = await self._request("GET", PATH_PLAYING) or {}
+        ips = sysinfo.get("ips") or []
+        disks = sysinfo.get("disks") or []
+        disk = disks[0] if disks else {}
+        return MisterStatus(
+            online=True,
+            core=playing.get("core") or None,
+            system=playing.get("system") or None,
+            system_name=playing.get("systemName") or None,
+            game=playing.get("game") or None,
+            game_name=playing.get("gameName") or None,
+            hostname=sysinfo.get("hostname"),
+            version=sysinfo.get("version"),
+            ips=ips,
+            ip=ips[0] if ips else None,
+            updated=sysinfo.get("updated"),
+            dns=sysinfo.get("dns"),
+            disk_total=disk.get("total"),
+            disk_used=disk.get("used"),
+            disk_free=disk.get("free"),
+        )
+
+    async def async_get_systems(self) -> list[dict]:
+        return await self._request("GET", PATH_SYSTEMS) or []
+
+    async def async_launch_system(self, system_id: str) -> None:
+        await self._request("POST", f"{PATH_SYSTEMS}/{system_id}")
+
+    async def async_launch_game(self, path: str) -> None:
+        await self._request("POST", PATH_GAMES_LAUNCH, payload={"path": path})
+
+    async def async_launch_menu(self) -> None:
+        await self._request("POST", PATH_LAUNCH_MENU)
+
+    async def async_search_games(self, query: str, system: str = "all") -> dict:
+        return (
+            await self._request(
+                "POST", PATH_GAMES_SEARCH, payload={"data": query, "system": system}
+            )
+            or {}
+        )
+
+    async def async_index_games(self) -> None:
+        await self._request("POST", PATH_GAMES_INDEX)
+
+    async def async_send_keyboard(self, name: str) -> None:
+        await self._request("POST", f"{PATH_KEYBOARD}/{name}")
+
+    async def async_reboot(self) -> None:
+        await self._request("POST", PATH_REBOOT)
+
+    async def async_restart_remote(self) -> None:
+        await self._request("POST", PATH_RESTART_REMOTE)
+
+    async def async_take_screenshot(self) -> None:
+        await self._request("POST", PATH_SCREENSHOTS)
+
+    async def async_get_screenshots(self) -> list[dict]:
+        return await self._request("GET", PATH_SCREENSHOTS) or []
+
+    async def async_get_screenshot_image(self, core: str, filename: str) -> bytes:
+        return await self._request(
+            "GET", f"{PATH_SCREENSHOTS}/{core}/{filename}", parse_json=False
+        )
+
+    async def async_get_music_status(self) -> dict:
+        return await self._request("GET", PATH_MUSIC_STATUS) or {}
+
+    async def async_music_play(self) -> None:
+        await self._request("POST", PATH_MUSIC_PLAY)
+
+    async def async_music_stop(self) -> None:
+        await self._request("POST", PATH_MUSIC_STOP)
+
+    async def async_music_next(self) -> None:
+        await self._request("POST", PATH_MUSIC_NEXT)
+
+    # --- Wallpapers ---
+    async def async_get_wallpapers(self) -> dict:
+        return await self._request("GET", PATH_WALLPAPERS) or {}
+
+    async def async_set_wallpaper(self, filename: str) -> None:
+        await self._request("POST", f"{PATH_WALLPAPERS}/{filename}")
+
+    async def async_clear_wallpaper(self) -> None:
+        await self._request("DELETE", PATH_WALLPAPERS)
+
+    # --- INI files ---
+    async def async_get_inis(self) -> dict:
+        return await self._request("GET", PATH_INIS) or {}
+
+    async def async_get_ini_values(self, ini_id: int) -> dict:
+        return await self._request("GET", f"{PATH_INIS}/{ini_id}") or {}
+
+    async def async_set_active_ini(self, ini_id: int) -> None:
+        await self._request("PUT", PATH_INIS, payload={"ini": ini_id})
+
+    async def async_set_ini_values(self, ini_id: int, values: dict) -> None:
+        await self._request("PUT", f"{PATH_INIS}/{ini_id}", payload=values)
+
+    async def async_set_background_mode(self, mode: int) -> None:
+        await self._request("PUT", PATH_CORE_MENU, payload={"mode": mode})
+
+    # --- Music (extended) ---
+    async def async_get_music_playlists(self) -> list[str]:
+        return await self._request("GET", PATH_MUSIC_PLAYLIST) or []
+
+    async def async_set_music_playlist(self, name: str) -> None:
+        await self._request("POST", f"{PATH_MUSIC_PLAYLIST}/{name}")
+
+    async def async_set_music_playback(self, mode: str) -> None:
+        await self._request("POST", f"{PATH_MUSIC_PLAYBACK}/{mode}")
+
+    # --- Scripts ---
+    async def async_get_scripts(self) -> dict:
+        return await self._request("GET", PATH_SCRIPTS_LIST) or {}
+
+    async def async_launch_script(self, filename: str) -> None:
+        await self._request("POST", f"{PATH_SCRIPTS_LAUNCH}/{filename}")
+
+    async def async_open_console(self) -> None:
+        await self._request("POST", PATH_SCRIPTS_CONSOLE)
+
+    async def async_kill_script(self) -> None:
+        await self._request("POST", PATH_SCRIPTS_KILL)
+
+    # --- Peers ---
+    async def async_get_peers(self) -> list[dict]:
+        data = await self._request("GET", PATH_PEERS) or {}
+        return data.get("peers", [])
+
+    # --- Launchers ---
+    async def async_launch_path(self, path: str) -> None:
+        await self._request("POST", PATH_LAUNCH, payload={"path": path})
+
+    async def async_launch_token(self, data: str) -> None:
+        await self._request("GET", f"{PATH_LAUNCH_TOKEN}/{data}")
+
+    async def async_create_shortcut(
+        self, game_path: str, folder: str, name: str
+    ) -> dict:
+        return await self._request(
+            "POST",
+            PATH_LAUNCH_NEW,
+            payload={"gamePath": game_path, "folder": folder, "name": name},
+        ) or {}
+
+    # --- Raw keyboard ---
+    async def async_send_keyboard_raw(self, code: int) -> None:
+        await self._request("POST", f"{PATH_KEYBOARD_RAW}/{code}")

mister_fpga/const.py

@@ -0,0 +1,62 @@
+"""Protocol constants for the MiSTer FPGA mrext Remote API."""
+from __future__ import annotations
+
+DEFAULT_PORT = 8182
+HTTP_TIMEOUT = 10
+
+# mrext Remote API paths (relative to base_url = http://host:port/api)
+PATH_PLAYING = "/games/playing"
+PATH_SYSINFO = "/sysinfo"
+PATH_SYSTEMS = "/systems"
+PATH_GAMES_LAUNCH = "/games/launch"
+PATH_GAMES_SEARCH = "/games/search"
+PATH_GAMES_INDEX = "/games/index"
+PATH_LAUNCH_MENU = "/launch/menu"
+PATH_KEYBOARD = "/controls/keyboard"
+PATH_REBOOT = "/settings/system/reboot"
+PATH_RESTART_REMOTE = "/settings/remote/restart"
+PATH_SCREENSHOTS = "/screenshots"
+PATH_MUSIC_STATUS = "/music/status"
+PATH_MUSIC_PLAY = "/music/play"
+PATH_MUSIC_STOP = "/music/stop"
+PATH_MUSIC_NEXT = "/music/next"
+PATH_MUSIC_PLAYLIST = "/music/playlist"
+PATH_MUSIC_PLAYBACK = "/music/playback"
+PATH_WALLPAPERS = "/wallpapers"
+PATH_INIS = "/settings/inis"
+PATH_CORE_MENU = "/settings/core/menu"
+PATH_SCRIPTS_LIST = "/scripts/list"
+PATH_SCRIPTS_LAUNCH = "/scripts/launch"
+PATH_SCRIPTS_CONSOLE = "/scripts/console"
+PATH_SCRIPTS_KILL = "/scripts/kill"
+PATH_PEERS = "/settings/remote/peers"
+PATH_LAUNCH = "/launch"
+PATH_LAUNCH_TOKEN = "/l"
+PATH_LAUNCH_NEW = "/launch/new"
+PATH_KEYBOARD_RAW = "/controls/keyboard-raw"
+
+# WebSocket endpoint (mounted under /api on Remote v0.4)
+WS_PATH = "/api/ws"
+
+# MiSTer.ini keys exposed as Number entities (value range 0-100)
+INI_VIDEO_KEYS = ("video_brightness", "video_contrast", "video_saturation")
+
+# SSH defaults and probe command
+DEFAULT_SSH_PORT = 22
+DEFAULT_SSH_USERNAME = "root"
+
+SSH_PROBE_CMD = (
+    "cat /tmp/CORENAME 2>/dev/null; echo '|||'; "
+    "cat /proc/uptime 2>/dev/null; echo '|||'; "
+    "cat /proc/loadavg 2>/dev/null; echo '|||'; "
+    "awk '/MemTotal|MemAvailable/{print $2}' /proc/meminfo 2>/dev/null; echo '|||'; "
+    "stat -c %Y /media/fat/MiSTer 2>/dev/null"
+)
+
+# Keyboard control names accepted by POST /controls/keyboard/{name}
+KEYBOARD_NAMES = (
+    "up", "down", "left", "right", "confirm", "back", "cancel", "menu",
+    "osd", "core_select", "user", "volume_up", "volume_down", "volume_mute",
+    "reset", "screenshot", "raw_screenshot", "console", "exit_console",
+    "computer_osd", "change_background", "pair_bluetooth", "toggle_core_dates",
+)

mister_fpga/ssh.py

@@ -0,0 +1,88 @@
+"""Optional SSH telemetry client for the MiSTer FPGA."""
+from __future__ import annotations
+
+import logging
+
+from .const import SSH_PROBE_CMD
+
+_LOGGER = logging.getLogger(__name__)
+
+_SEP = "|||"
+
+
+def parse_ssh_probe(raw: str) -> dict:
+    """Parse the batched SSH probe output into a telemetry dict. Tolerant of blanks."""
+    parts = [p.strip() for p in raw.split(_SEP)]
+    while len(parts) < 5:
+        parts.append("")
+    core, uptime_s, load_s, mem_s, fw_s = parts[:5]
+
+    def _int(value: str) -> int | None:
+        try:
+            return int(float(value))
+        except (TypeError, ValueError):
+            return None
+
+    uptime = _int(uptime_s.split()[0]) if uptime_s else None
+    load_1m = None
+    if load_s:
+        try:
+            load_1m = float(load_s.split()[0])
+        except (ValueError, IndexError):
+            load_1m = None
+    mem_used_pct = None
+    mem_lines = [m for m in mem_s.splitlines() if m]
+    if len(mem_lines) >= 2:
+        total = _int(mem_lines[0])
+        avail = _int(mem_lines[1])
+        if total:
+            mem_used_pct = round((total - avail) / total * 100, 1)
+    fw_ts = _int(fw_s) if fw_s else None
+
+    return {
+        "active_core": core or None,
+        "uptime_seconds": uptime,
+        "cpu_load_1m": load_1m,
+        "memory_used_percent": mem_used_pct,
+        "firmware_timestamp": fw_ts,
+    }
+
+
+class MisterSSH:
+    """Maintains a persistent asyncssh connection and runs the probe."""
+
+    def __init__(self, host: str, port: int, username: str, password: str) -> None:
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self._conn = None
+
+    async def _ensure(self) -> None:
+        if self._conn is not None:
+            return
+        import asyncssh
+
+        self._conn = await asyncssh.connect(
+            self.host,
+            port=self.port,
+            username=self.username,
+            password=self.password,
+            known_hosts=None,
+        )
+
+    async def async_probe(self) -> dict:
+        """Run the probe; returns {} on any failure (SSH is best-effort)."""
+        try:
+            await self._ensure()
+            result = await self._conn.run(SSH_PROBE_CMD, check=False, timeout=10)
+            return parse_ssh_probe(result.stdout or "")
+        except Exception as err:  # noqa: BLE001 - asyncssh raises many types; SSH is best-effort and must never break the HTTP integration
+            _LOGGER.debug("MiSTer SSH probe failed: %s", err)
+            self._conn = None
+            return {}
+
+    async def async_close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None

mister_fpga/websocket.py

@@ -0,0 +1,103 @@
+"""WebSocket client for real-time MiSTer Remote updates."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import replace
+
+import aiohttp
+
+from .client import MisterStatus
+from .const import WS_PATH
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def apply_ws_message(
+    message: str,
+    status: MisterStatus,
+    menu_path: str | None,
+    index_state: tuple[bool, bool],
+) -> tuple[MisterStatus, str | None, tuple[bool, bool]]:
+    """Pure reducer: apply one WS text frame to (status, menu_path, index_state)."""
+    prefix, _, rest = message.partition(":")
+    if prefix == "coreRunning":
+        core = rest.strip() or None
+        if core is None:
+            return (
+                replace(status, core=None, game=None, game_name=None),
+                menu_path,
+                index_state,
+            )
+        return replace(status, core=core), menu_path, index_state
+    if prefix == "gameRunning":
+        rest = rest.strip()
+        if not rest:
+            return replace(status, game=None, game_name=None), menu_path, index_state
+        _, _, name = rest.partition("/")
+        game_name = name.rsplit(".", 1)[0] if name else None
+        return replace(status, game=rest, game_name=game_name), menu_path, index_state
+    if prefix == "menuNavigation":
+        return status, rest.strip() or None, index_state
+    if prefix == "indexStatus":
+        parts = rest.split(",")
+        exists = len(parts) > 0 and parts[0] == "y"
+        in_progress = len(parts) > 1 and parts[1] == "y"
+        return status, menu_path, (exists, in_progress)
+    return status, menu_path, index_state
+
+
+class MisterWebSocketClient:
+    """Connects to the mrext Remote WebSocket and invokes a callback per text frame."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 8182,
+        *,
+        session=None,
+        reconnect_delay: int = 5,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self._session = session
+        self._owns_session = session is None
+        self._reconnect_delay = reconnect_delay
+        self._stop = False
+
+    @property
+    def url(self) -> str:
+        return f"ws://{self.host}:{self.port}{WS_PATH}"
+
+    async def listen(self, on_message) -> None:
+        """Run the reconnect loop, calling on_message(text) for each TEXT frame.
+
+        on_message may be sync or async. Runs until stop() or cancellation.
+        """
+        owns = self._session is None
+        session = self._session or aiohttp.ClientSession()
+        try:
+            while not self._stop:
+                try:
+                    async with session.ws_connect(self.url, heartbeat=30) as ws:
+                        async for msg in ws:
+                            if msg.type == aiohttp.WSMsgType.TEXT:
+                                result = on_message(msg.data)
+                                if hasattr(result, "__await__"):
+                                    await result
+                            elif msg.type in (
+                                aiohttp.WSMsgType.CLOSED,
+                                aiohttp.WSMsgType.ERROR,
+                            ):
+                                break
+                except (aiohttp.ClientError, TimeoutError):
+                    pass
+                if self._stop:
+                    break
+                await asyncio.sleep(self._reconnect_delay)
+        finally:
+            if owns:
+                await session.close()
+
+    def stop(self) -> None:
+        self._stop = True

python_mister_fpga-0.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: python-mister-fpga
+Version: 0.1.0
+Summary: Async Python client for the MiSTer FPGA mrext Remote API (REST + WebSocket) and SSH telemetry
+Project-URL: Homepage, https://github.com/hudsonbrendon/python-mister-fpga
+Project-URL: Issues, https://github.com/hudsonbrendon/python-mister-fpga/issues
+Author-email: Hudson Brendon <contato.hudsonbrendon@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: aiohttp,async,fpga,mister,mrext,retro
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: asyncssh>=2.21
+Provides-Extra: test
+Requires-Dist: aioresponses>=0.7; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/dark_logo.png" width="420">
+    <img src="assets/logo.png" alt="python-mister-fpga" width="420">
+  </picture>
+</p>
+
+# python-mister-fpga
+
+[![Tests](https://github.com/hudsonbrendon/python-mister-fpga/actions/workflows/tests.yml/badge.svg)](https://github.com/hudsonbrendon/python-mister-fpga/actions/workflows/tests.yml)
+[![PyPI version](https://img.shields.io/pypi/v/python-mister-fpga)](https://pypi.org/project/python-mister-fpga/)
+[![Python versions](https://img.shields.io/pypi/pyversions/python-mister-fpga)](https://pypi.org/project/python-mister-fpga/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Async Python client for the [mrext Remote API](https://github.com/wizzomafizzo/mrext) (REST + WebSocket) and optional SSH telemetry for the MiSTer FPGA. Zero Home Assistant dependency — use it in any Python project.
+
+## Install
+
+```bash
+pip install python-mister-fpga
+```
+
+## Usage
+
+### REST client
+
+```python
+import asyncio
+from mister_fpga import MisterClient
+
+async def main():
+    client = MisterClient("192.168.1.50")
+    status = await client.async_get_status()
+    print(status.core, status.game)
+    await client.async_launch_game("/media/fat/games/SNES/Chrono.sfc")
+    await client.async_close()
+
+asyncio.run(main())
+```
+
+### WebSocket (real-time updates)
+
+```python
+import asyncio
+from mister_fpga import MisterWebSocketClient, MisterStatus, apply_ws_message
+
+state = MisterStatus(online=True)
+menu_path = None
+index_state = (False, False)
+
+def on_message(text: str) -> None:
+    global state, menu_path, index_state
+    state, menu_path, index_state = apply_ws_message(text, state, menu_path, index_state)
+    print(state.core, state.game)
+
+async def main():
+    ws = MisterWebSocketClient("192.168.1.50")
+    await ws.listen(on_message)
+
+asyncio.run(main())
+```
+
+### SSH telemetry
+
+```python
+import asyncio
+from mister_fpga import MisterSSH
+
+async def main():
+    ssh = MisterSSH("192.168.1.50", 22, "root", "1")
+    data = await ssh.async_probe()
+    print(data)
+    await ssh.async_close()
+
+asyncio.run(main())
+```
+
+## API
+
+- **`MisterClient(host, port=8182, *, session=None, timeout=10)`** — async REST client; call `await client.async_close()` when done, or inject your own `aiohttp.ClientSession`.
+- **`MisterStatus`** — dataclass snapshot: `online`, `core`, `system`, `game`, `hostname`, `version`, `ip`, `ips`, `dns`, `disk_total/used/free`. Property `is_running_game`.
+- **`MisterConnectionError`** — raised on network/HTTP errors.
+- **`MisterWebSocketClient(host, port=8182, *, session=None, reconnect_delay=5)`** — reconnecting WS loop; `await ws.listen(callback)`, call `ws.stop()` to exit.
+- **`apply_ws_message(message, status, menu_path, index_state)`** — pure reducer; apply a single WS text frame and return updated `(status, menu_path, index_state)`.
+- **`MisterSSH(host, port, username, password)`** — persistent asyncssh connection; `await ssh.async_probe()` returns telemetry dict.
+- **`parse_ssh_probe(raw)`** — parse the raw batched SSH output into a telemetry dict.
+- **`KEYBOARD_NAMES`**, **`INI_VIDEO_KEYS`**, **`WS_PATH`**, **`DEFAULT_PORT`** — protocol constants.
+
+## Credits
+
+REST/WebSocket API by [wizzomafizzo/mrext](https://github.com/wizzomafizzo/mrext). MiSTer-kun logo by the MiSTer-devel project. Author [@hudsonbrendon](https://github.com/hudsonbrendon).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

python_mister_fpga-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+mister_fpga/__init__.py,sha256=J7zvYdc0fwYxXaJYdmemVcJL1c0zJKSC9Lmkg9k_qa8,592
+mister_fpga/client.py,sha256=4OHlmnEvh-opy4vTFdWYPmggIOeDhzbqS1CdGUC7Uyk,9828
+mister_fpga/const.py,sha256=Lb0CC5eK4r9dJH4RQtjEmSb6VgTE-TaEqycCuAud6VE,2223
+mister_fpga/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mister_fpga/ssh.py,sha256=sP9OLmn7v7VZHLIG2YVZdgjBMKEXAT-JWymu7Elf-OA,2700
+mister_fpga/websocket.py,sha256=1pWvaxLOVeQsYcW40tviowkXupX3pahNW2E8YoJDiY8,3525
+python_mister_fpga-0.1.0.dist-info/METADATA,sha256=N7Byl3ApzL1y1up8_qkh6u5CG3jXaZSAxMy8ufEZWok,4631
+python_mister_fpga-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_mister_fpga-0.1.0.dist-info/licenses/LICENSE,sha256=4Zgd3fbLJqWSkwKA-hh1rNN6DC9tNQ3rWLX93fingOw,1071
+python_mister_fpga-0.1.0.dist-info/RECORD,,

python_mister_fpga-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

python_mister_fpga-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hudson Brendon
+
+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.