esp32io-mqtt 0.1.0__tar.gz

esp32io_mqtt-0.1.0/LICENSE

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

esp32io_mqtt-0.1.0/PKG-INFO

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: esp32io-mqtt
+Version: 0.1.0
+Summary: A lightweight Python MQTT client for controlling ESP32IO-MQTT devices (Home Assistant compatible).
+Author: Noritama-Lab
+License: MIT
+Project-URL: Repository, https://github.com/Noritama-Lab/esp32io-mqtt-api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT 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 :: System :: Hardware
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paho-mqtt<2.0,>=1.6
+Dynamic: license-file
+
+# ESP32IO-MQTT Python MQTT Client
+
+ESP32IO-MQTT is a lightweight Python **MQTT** client for controlling [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware) devices.
+
+日本語 / English
+
+---
+
+## 日本語
+
+ESP32IO-MQTT Pythonクライアントは、**MQTTブローカー** 経由で ESP32IO-MQTT ファームウェアを制御するための軽量Pythonクライアントです。
+
+ESP32IO-MQTT ファームウェアはデバイス制御を **MQTT** 経由で行います。本クライアントもMQTT専用です。
+
+---
+
+## 特徴
+
+- MQTTブローカー経由での接続のみをサポート（HTTP/シリアルは非対応）
+- 汎用JSONコマンドチャネル (`<base>/cmd` → `<base>/cmd/result`) を使った同期API (`read_di()`, `set_do()`, `get_io_state()` 等)
+- 個別エンティティのトピック (Home Assistant MQTT Discovery互換) にも対応
+  - `get_cached_state()` で直近受信した状態のスナップショットを取得
+  - `on_state_change()` で状態変化のコールバックを登録
+  - `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()` で応答待ちなしに直接publish
+- I2Cスキャン、リード/ライト、BME280/MPU6050/VL53L1Xなどのセンサー一括取得、OLED表示をサポート
+- PWM周波数・分解能の取得/更新に対応
+- 通信エラー・タイムアウト・プロトコル不整合・デバイスエラーなど統一例外を定義
+- 任意JSONを送れる低レベルAPI `command()` を提供
+
+---
+
+## 動作環境
+
+- Python 3.8 以上
+- `paho-mqtt>=1.6,<2.0`
+- MQTTブローカー (Mosquitto等)
+- ESP32IO-MQTT ファームウェア（MQTT対応）
+
+---
+
+## インストール
+
+```bash
+pip install -r requirements.txt
+# または
+pip install -e .
+```
+
+---
+
+## クイックスタート
+
+```python
+from esp32io_mqtt import ESP32S3IOMqtt
+
+# DEVICE_ID は設定ポータル (http://<device_ip>/) のページタイトルや
+# mDNSホスト名 (ESP32IO_MQTT_XXXXXX) で確認できます。
+with ESP32S3IOMqtt("ESP32IO_MQTT_XXXXXX", "192.168.1.5", debug=False) as esp:
+    print("ping =", esp.ping())
+    print("di0 =", esp.read_di(0))
+    print("adc0 =", esp.read_adc(0))
+    print("pwm config =", esp.get_pwm_config())
+
+    esp.set_do(0, 1)
+    esp.set_pwm(0, 128)
+
+    print(esp.get_io_state())
+```
+
+サンプル実行:
+
+```bash
+py -m examples.mqtt_example
+```
+
+---
+
+## 通信方式
+
+### 1. 汎用JSONコマンドチャネル (同期API)
+
+`command()` および `read_di()` / `set_do()` などの高レベルメソッドは、`<base>/cmd` にJSONをpublishし `<base>/cmd/result` の応答を待つ同期方式です。戻り値やエラー(`ESP32IODeviceError`)で結果を確認できます。
+
+### 2. 個別エンティティのトピック (Home Assistant MQTT Discovery互換)
+
+接続時に `di/+/state` `do/+/state` `pwm/+/state` `rgb/state` `led_mode/state` `oled/state` `bme280/#` `mpu6050/#` `vl53l1x/#` `diag/#` `status` を自動的にsubscribeし、受信するたびに内部キャッシュへ保存します。
+
+- `get_cached_state()` — 直近に受信した値のスナップショット (dict) を取得
+- `on_state_change(callback)` — 状態トピックを受信するたびに `callback(topic_suffix, payload)` を呼び出す
+- `is_online` — LWTトピック (`<base>/status`) が `online` かどうか
+- `publish_do(pin_id, value)` / `publish_pwm(pin_id, duty)` / `publish_rgb(r, g, b, brightness)` / `publish_led_off()` / `publish_led_mode(mode)` / `publish_oled(text)` — 応答を待たずに直接publish（Home Assistant側からの操作と同じ経路）
+
+---
+
+## API 一覧（主要メソッド）
+
+- `ESP32S3IOMqtt(device_id, host, port=1883, user=None, password=None, topic_root="esp32io", keepalive=30, cmd_timeout=5.0, connect_timeout=10.0, debug=False)`
+- `ping()`
+- `read_di(pin_id)` / `set_do(pin_id, value)`
+- `read_adc(pin_id)`
+- `set_pwm(pin_id, duty)`
+- `get_pwm_config()` / `set_pwm_config(freq, res)`
+- `set_led_mode(mode)` / `set_rgb(r, g, b, brightness)` / `led_off()` / `get_led_state()`
+- `i2c_scan()` / `i2c_read(addr, length)` / `i2c_write(addr, data)`
+- `get_sensors()`
+- `set_oled(text, x, y, size, clear)`
+- `get_io_state()` / `get_status()`
+- `command(cmd, **kwargs)`
+- `help()`
+- `get_cached_state()` / `on_state_change(callback)` / `is_online`
+- `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()`
+- `close()`
+
+---
+
+## 例外
+
+- `ESP32IOError`（基底クラス）
+- `ESP32IOMqttError` — ブローカー接続・publish失敗
+- `ESP32IOTimeoutError` — `cmd/result` 応答待ちのタイムアウト（`ESP32IOMqttError`のサブクラス）
+- `ESP32IOProtocolError` — デバイスから不正な応答
+- `ESP32IODeviceError` — デバイスが `status=error` を返した場合
+
+---
+
+## プロジェクト構成
+
+```text
+.
+├── esp32io_mqtt/
+│   ├── __init__.py
+│   ├── client.py
+│   ├── exceptions.py
+│   └── protocol.py
+├── examples/
+│   ├── mqtt_example.py
+│   └── i2c_example.py
+├── pyproject.toml
+├── requirements.txt
+├── LICENSE
+└── README.md
+```
+
+---
+
+## ファームウェア
+
+対応ファームウェア: [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware)（MQTT + Home Assistant MQTT Discovery対応）。
+トピック構成・汎用JSONコマンド一覧は同リポジトリの `COMMAND_REFERENCE.md` を参照してください。
+
+---
+
+## ライセンス
+
+MIT License
+Copyright (c) 2026 Noritama-Lab
+
+---
+
+## English
+
+ESP32IO-MQTT Python client is a lightweight **MQTT** client for controlling [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware) firmware.
+
+ESP32IO-MQTT firmware controls devices over **MQTT**. This client is MQTT-only.
+
+### Features
+
+- MQTT broker connection only (no HTTP/Serial support)
+- Synchronous API over the generic JSON command channel (`<base>/cmd` → `<base>/cmd/result`) (`read_di()`, `set_do()`, `get_io_state()`, etc.)
+- Support for individual entity topics (Home Assistant MQTT Discovery compatible)
+  - `get_cached_state()` for a snapshot of the latest received state
+  - `on_state_change()` to register a callback for state changes
+  - `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()` to publish directly without waiting for a response
+- I2C scanning, raw read/write, sensor batch reads (BME280/MPU6050/VL53L1X), and OLED control
+- PWM frequency/resolution read & update
+- Unified exceptions for MQTT, protocol, timeout, and device errors
+- Low-level `command()` API for custom JSON commands
+
+### Requirements
+
+- Python 3.8+
+- `paho-mqtt>=1.6,<2.0`
+- An MQTT broker (e.g. Mosquitto)
+- ESP32IO-MQTT firmware (MQTT-based)
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+# or
+pip install -e .
+```
+
+### Quick Start
+
+```python
+from esp32io_mqtt import ESP32S3IOMqtt
+
+with ESP32S3IOMqtt("ESP32IO_MQTT_XXXXXX", "192.168.1.5", debug=False) as esp:
+    print("ping =", esp.ping())
+    print("di0 =", esp.read_di(0))
+    esp.set_do(0, 1)
+    print(esp.get_io_state())
+```
+
+### License
+
+MIT License
+Copyright (c) 2026 Noritama-Lab

esp32io_mqtt-0.1.0/README.md

@@ -0,0 +1,209 @@
+# ESP32IO-MQTT Python MQTT Client
+
+ESP32IO-MQTT is a lightweight Python **MQTT** client for controlling [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware) devices.
+
+日本語 / English
+
+---
+
+## 日本語
+
+ESP32IO-MQTT Pythonクライアントは、**MQTTブローカー** 経由で ESP32IO-MQTT ファームウェアを制御するための軽量Pythonクライアントです。
+
+ESP32IO-MQTT ファームウェアはデバイス制御を **MQTT** 経由で行います。本クライアントもMQTT専用です。
+
+---
+
+## 特徴
+
+- MQTTブローカー経由での接続のみをサポート（HTTP/シリアルは非対応）
+- 汎用JSONコマンドチャネル (`<base>/cmd` → `<base>/cmd/result`) を使った同期API (`read_di()`, `set_do()`, `get_io_state()` 等)
+- 個別エンティティのトピック (Home Assistant MQTT Discovery互換) にも対応
+  - `get_cached_state()` で直近受信した状態のスナップショットを取得
+  - `on_state_change()` で状態変化のコールバックを登録
+  - `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()` で応答待ちなしに直接publish
+- I2Cスキャン、リード/ライト、BME280/MPU6050/VL53L1Xなどのセンサー一括取得、OLED表示をサポート
+- PWM周波数・分解能の取得/更新に対応
+- 通信エラー・タイムアウト・プロトコル不整合・デバイスエラーなど統一例外を定義
+- 任意JSONを送れる低レベルAPI `command()` を提供
+
+---
+
+## 動作環境
+
+- Python 3.8 以上
+- `paho-mqtt>=1.6,<2.0`
+- MQTTブローカー (Mosquitto等)
+- ESP32IO-MQTT ファームウェア（MQTT対応）
+
+---
+
+## インストール
+
+```bash
+pip install -r requirements.txt
+# または
+pip install -e .
+```
+
+---
+
+## クイックスタート
+
+```python
+from esp32io_mqtt import ESP32S3IOMqtt
+
+# DEVICE_ID は設定ポータル (http://<device_ip>/) のページタイトルや
+# mDNSホスト名 (ESP32IO_MQTT_XXXXXX) で確認できます。
+with ESP32S3IOMqtt("ESP32IO_MQTT_XXXXXX", "192.168.1.5", debug=False) as esp:
+    print("ping =", esp.ping())
+    print("di0 =", esp.read_di(0))
+    print("adc0 =", esp.read_adc(0))
+    print("pwm config =", esp.get_pwm_config())
+
+    esp.set_do(0, 1)
+    esp.set_pwm(0, 128)
+
+    print(esp.get_io_state())
+```
+
+サンプル実行:
+
+```bash
+py -m examples.mqtt_example
+```
+
+---
+
+## 通信方式
+
+### 1. 汎用JSONコマンドチャネル (同期API)
+
+`command()` および `read_di()` / `set_do()` などの高レベルメソッドは、`<base>/cmd` にJSONをpublishし `<base>/cmd/result` の応答を待つ同期方式です。戻り値やエラー(`ESP32IODeviceError`)で結果を確認できます。
+
+### 2. 個別エンティティのトピック (Home Assistant MQTT Discovery互換)
+
+接続時に `di/+/state` `do/+/state` `pwm/+/state` `rgb/state` `led_mode/state` `oled/state` `bme280/#` `mpu6050/#` `vl53l1x/#` `diag/#` `status` を自動的にsubscribeし、受信するたびに内部キャッシュへ保存します。
+
+- `get_cached_state()` — 直近に受信した値のスナップショット (dict) を取得
+- `on_state_change(callback)` — 状態トピックを受信するたびに `callback(topic_suffix, payload)` を呼び出す
+- `is_online` — LWTトピック (`<base>/status`) が `online` かどうか
+- `publish_do(pin_id, value)` / `publish_pwm(pin_id, duty)` / `publish_rgb(r, g, b, brightness)` / `publish_led_off()` / `publish_led_mode(mode)` / `publish_oled(text)` — 応答を待たずに直接publish（Home Assistant側からの操作と同じ経路）
+
+---
+
+## API 一覧（主要メソッド）
+
+- `ESP32S3IOMqtt(device_id, host, port=1883, user=None, password=None, topic_root="esp32io", keepalive=30, cmd_timeout=5.0, connect_timeout=10.0, debug=False)`
+- `ping()`
+- `read_di(pin_id)` / `set_do(pin_id, value)`
+- `read_adc(pin_id)`
+- `set_pwm(pin_id, duty)`
+- `get_pwm_config()` / `set_pwm_config(freq, res)`
+- `set_led_mode(mode)` / `set_rgb(r, g, b, brightness)` / `led_off()` / `get_led_state()`
+- `i2c_scan()` / `i2c_read(addr, length)` / `i2c_write(addr, data)`
+- `get_sensors()`
+- `set_oled(text, x, y, size, clear)`
+- `get_io_state()` / `get_status()`
+- `command(cmd, **kwargs)`
+- `help()`
+- `get_cached_state()` / `on_state_change(callback)` / `is_online`
+- `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()`
+- `close()`
+
+---
+
+## 例外
+
+- `ESP32IOError`（基底クラス）
+- `ESP32IOMqttError` — ブローカー接続・publish失敗
+- `ESP32IOTimeoutError` — `cmd/result` 応答待ちのタイムアウト（`ESP32IOMqttError`のサブクラス）
+- `ESP32IOProtocolError` — デバイスから不正な応答
+- `ESP32IODeviceError` — デバイスが `status=error` を返した場合
+
+---
+
+## プロジェクト構成
+
+```text
+.
+├── esp32io_mqtt/
+│   ├── __init__.py
+│   ├── client.py
+│   ├── exceptions.py
+│   └── protocol.py
+├── examples/
+│   ├── mqtt_example.py
+│   └── i2c_example.py
+├── pyproject.toml
+├── requirements.txt
+├── LICENSE
+└── README.md
+```
+
+---
+
+## ファームウェア
+
+対応ファームウェア: [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware)（MQTT + Home Assistant MQTT Discovery対応）。
+トピック構成・汎用JSONコマンド一覧は同リポジトリの `COMMAND_REFERENCE.md` を参照してください。
+
+---
+
+## ライセンス
+
+MIT License
+Copyright (c) 2026 Noritama-Lab
+
+---
+
+## English
+
+ESP32IO-MQTT Python client is a lightweight **MQTT** client for controlling [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware) firmware.
+
+ESP32IO-MQTT firmware controls devices over **MQTT**. This client is MQTT-only.
+
+### Features
+
+- MQTT broker connection only (no HTTP/Serial support)
+- Synchronous API over the generic JSON command channel (`<base>/cmd` → `<base>/cmd/result`) (`read_di()`, `set_do()`, `get_io_state()`, etc.)
+- Support for individual entity topics (Home Assistant MQTT Discovery compatible)
+  - `get_cached_state()` for a snapshot of the latest received state
+  - `on_state_change()` to register a callback for state changes
+  - `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()` to publish directly without waiting for a response
+- I2C scanning, raw read/write, sensor batch reads (BME280/MPU6050/VL53L1X), and OLED control
+- PWM frequency/resolution read & update
+- Unified exceptions for MQTT, protocol, timeout, and device errors
+- Low-level `command()` API for custom JSON commands
+
+### Requirements
+
+- Python 3.8+
+- `paho-mqtt>=1.6,<2.0`
+- An MQTT broker (e.g. Mosquitto)
+- ESP32IO-MQTT firmware (MQTT-based)
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+# or
+pip install -e .
+```
+
+### Quick Start
+
+```python
+from esp32io_mqtt import ESP32S3IOMqtt
+
+with ESP32S3IOMqtt("ESP32IO_MQTT_XXXXXX", "192.168.1.5", debug=False) as esp:
+    print("ping =", esp.ping())
+    print("di0 =", esp.read_di(0))
+    esp.set_do(0, 1)
+    print(esp.get_io_state())
+```
+
+### License
+
+MIT License
+Copyright (c) 2026 Noritama-Lab

esp32io_mqtt-0.1.0/esp32io_mqtt/__init__.py

@@ -0,0 +1,17 @@
+from .client import ESP32S3IOMqtt
+from .exceptions import (
+    ESP32IOError,
+    ESP32IODeviceError,
+    ESP32IOMqttError,
+    ESP32IOTimeoutError,
+    ESP32IOProtocolError,
+)
+
+__all__ = [
+    "ESP32S3IOMqtt",
+    "ESP32IOError",
+    "ESP32IODeviceError",
+    "ESP32IOMqttError",
+    "ESP32IOTimeoutError",
+    "ESP32IOProtocolError",
+]

esp32io_mqtt-0.1.0/esp32io_mqtt/client.py

@@ -0,0 +1,345 @@
+import json
+import uuid
+import logging
+import threading
+from typing import Optional, Dict, Any, List, Literal, Callable
+
+import paho.mqtt.client as mqtt
+
+from .exceptions import (
+    ESP32IODeviceError,
+    ESP32IOMqttError,
+    ESP32IOTimeoutError,
+    ESP32IOProtocolError,
+)
+from . import protocol
+
+logger = logging.getLogger(__name__)
+
+
+class ESP32S3IOMqtt:
+    """MQTTブローカー経由でESP32IO-MQTTデバイスを操作するクライアント。
+
+    デバイス制御には2通りの経路がある:
+      - 汎用JSONコマンドチャネル (``command()`` および各 ``read_*``/``set_*`` メソッド):
+        `<base>/cmd` にpublishし `<base>/cmd/result` の応答を同期的に待つ。旧HTTP/Serial版と同じ使用感。
+      - 個別エンティティのトピック (Home Assistant MQTT Discovery互換):
+        `get_cached_state()` で直近の受信値を参照でき、``publish_*`` 系メソッドで
+        応答待ちなしに状態変更を発行できる。
+    """
+
+    def __init__(
+        self,
+        device_id: str,
+        host: str,
+        port: int = 1883,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        topic_root: str = protocol.DEFAULT_TOPIC_ROOT,
+        keepalive: int = 30,
+        cmd_timeout: float = 5.0,
+        connect_timeout: float = 10.0,
+        debug: bool = False,
+    ):
+        if debug:
+            logging.basicConfig(level=logging.DEBUG)
+
+        self.device_id = device_id
+        self.base = f"{topic_root}/{device_id}"
+        self.cmd_timeout = cmd_timeout
+
+        self._state: Dict[str, str] = {}
+        self._state_lock = threading.Lock()
+        self._listeners: List[Callable[[str, str], None]] = []
+
+        self._connected_event = threading.Event()
+        self._cmd_lock = threading.Lock()  # 汎用コマンドチャネルは一度に1件のみ処理
+        self._cmd_response_event = threading.Event()
+        self._cmd_response: Optional[Dict[str, Any]] = None
+
+        self._client = mqtt.Client(client_id=f"esp32io-mqtt-py-{uuid.uuid4().hex[:8]}")
+        if user:
+            self._client.username_pw_set(user, password or "")
+        self._client.on_connect = self._on_connect
+        self._client.on_disconnect = self._on_disconnect
+        self._client.on_message = self._on_message
+
+        try:
+            self._client.connect(host, port, keepalive=keepalive)
+        except OSError as e:
+            raise ESP32IOMqttError(f"Failed to connect to broker {host}:{port}: {e}")
+
+        self._client.loop_start()
+        if not self._connected_event.wait(connect_timeout):
+            self._client.loop_stop()
+            raise ESP32IOMqttError(f"Timed out connecting to broker {host}:{port}")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, _exc_type, _exc_val, _exc_tb):
+        self.close()
+
+    def _log(self, *args: Any) -> None:
+        logger.debug(" ".join(map(str, args)))
+
+    # ------------------------------------------------------------------
+    # 接続 / 購読 / 状態キャッシュ
+    # ------------------------------------------------------------------
+    def _on_connect(self, client, _userdata, _flags, rc):
+        if rc != 0:
+            logger.error("MQTT connect failed rc=%s", rc)
+            return
+        client.subscribe(f"{self.base}/cmd/result")
+        for pattern in protocol.ENTITY_SUBSCRIBE_TOPICS:
+            client.subscribe(pattern.format(base=self.base))
+        self._connected_event.set()
+
+    def _on_disconnect(self, _client, _userdata, _rc):
+        self._connected_event.clear()
+
+    def _on_message(self, _client, _userdata, msg):
+        payload = msg.payload.decode("utf-8", errors="replace")
+        self._log(f"RECV: {msg.topic} {payload}")
+
+        if msg.topic == f"{self.base}/cmd/result":
+            try:
+                self._cmd_response = json.loads(payload)
+            except json.JSONDecodeError:
+                logger.warning("Invalid JSON on cmd/result: %s", payload)
+                return
+            self._cmd_response_event.set()
+            return
+
+        suffix = msg.topic[len(self.base) + 1:]
+        with self._state_lock:
+            self._state[suffix] = payload
+        for listener in list(self._listeners):
+            try:
+                listener(suffix, payload)
+            except Exception:
+                logger.exception("State listener raised an exception")
+
+    def on_state_change(self, callback: Callable[[str, str], None]) -> None:
+        """個別エンティティのトピック受信ごとに ``callback(topic_suffix, payload)`` を呼び出す。"""
+        self._listeners.append(callback)
+
+    def get_cached_state(self) -> Dict[str, str]:
+        """個別エンティティのトピックから直近に受信した値のスナップショットを返す。"""
+        with self._state_lock:
+            return dict(self._state)
+
+    @property
+    def is_online(self) -> bool:
+        """デバイスのLWTトピック (`<base>/status`) が ``online`` かどうか。"""
+        return self._state.get("status") == "online"
+
+    # ------------------------------------------------------------------
+    # 汎用JSONコマンドチャネル (`<base>/cmd` -> `<base>/cmd/result`)
+    # ------------------------------------------------------------------
+    def command(self, cmd: str, **kwargs: Any) -> Dict[str, Any]:
+        """任意のコマンドを送信し、JSON応答を返す低レベルAPI"""
+        payload = {"cmd": cmd}
+        payload.update(kwargs)
+        return self._execute(payload)
+
+    def _execute(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        cmd_name = payload.get("cmd", "unknown")
+        with self._cmd_lock:
+            self._cmd_response = None
+            self._cmd_response_event.clear()
+
+            line = json.dumps(payload, separators=(",", ":"))
+            self._log(f"SEND: {line}")
+            info = self._client.publish(f"{self.base}/cmd", line, qos=0)
+            if info.rc != mqtt.MQTT_ERR_SUCCESS:
+                raise ESP32IOMqttError(f"Publish failed for '{cmd_name}': rc={info.rc}")
+
+            if not self._cmd_response_event.wait(self.cmd_timeout):
+                raise ESP32IOTimeoutError(f"Timeout waiting for response to '{cmd_name}'")
+
+            response = self._cmd_response
+            assert response is not None
+            return self._process_response(response, cmd_name)
+
+    def _process_response(self, data: Dict[str, Any], cmd: str) -> Dict[str, Any]:
+        if data.get("status") == "error":
+            code = data.get("code", "UNKNOWN")
+            detail = data.get("detail", "")
+            raise ESP32IODeviceError(f"Device error on '{cmd}': {code} ({detail})")
+        return data
+
+    def ping(self) -> bool:
+        """疎通確認"""
+        res = self.command(protocol.CMD_PING)
+        return res.get("message") == "pong"
+
+    def get_status(self) -> Dict[str, Any]:
+        """デバイスの稼働状況（起動時間、ヒープ、IP等）を取得"""
+        return self.command(protocol.CMD_GET_STATUS)
+
+    def get_io_state(self) -> Dict[str, Any]:
+        """DI, DO, ADC, PWM の全状態を一括取得"""
+        res = self.command(protocol.CMD_GET_IO_STATE)
+        return {
+            "dio_in":  list(res.get("dio_in", [])),
+            "dio_out": list(res.get("dio_out", [])),
+            "adc":     list(res.get("adc", [])),
+            "pwm":     list(res.get("pwm", [])),
+        }
+
+    def read_di(self, pin_id: int) -> int:
+        """デジタル入力の読み取り"""
+        if not isinstance(pin_id, int):
+            raise ValueError("pin_id must be an integer")
+        res = self.command(protocol.CMD_READ_DI, pin_id=pin_id)
+        val = res.get("value")
+        if not isinstance(val, int):
+            raise ESP32IOProtocolError(f"Invalid read_di response: {res}")
+        return val
+
+    def set_do(self, pin_id: int, value: int) -> bool:
+        """デジタル出力の設定 (0 or 1)"""
+        if value not in (0, 1):
+            raise ValueError("value must be 0 or 1")
+        res = self.command(protocol.CMD_SET_DO, pin_id=pin_id, value=value)
+        return res.get("status") == "ok"
+
+    def read_adc(self, pin_id: int) -> int:
+        """アナログ入力の読み取り"""
+        if not isinstance(pin_id, int):
+            raise ValueError("pin_id must be an integer")
+        res = self.command(protocol.CMD_READ_ADC, pin_id=pin_id)
+        val = res.get("value")
+        if not isinstance(val, int):
+            raise ESP32IOProtocolError(f"Invalid read_adc response: {res}")
+        return val
+
+    def set_pwm(self, pin_id: int, duty: int) -> bool:
+        """PWM出力の設定"""
+        if duty < 0:
+            raise ValueError("duty must be 0 or greater")
+        res = self.command(protocol.CMD_SET_PWM, pin_id=pin_id, duty=duty)
+        return res.get("status") == "ok"
+
+    def get_pwm_config(self) -> Dict[str, int]:
+        """現在のPWM周波数、分解能、および最大デューティを取得"""
+        res = self.command(protocol.CMD_GET_PWM_CONFIG)
+        if not all(isinstance(res.get(k), int) for k in ("freq", "res", "max_duty")):
+            raise ESP32IOProtocolError(f"Invalid get_pwm_config response: {res}")
+        return {"freq": res["freq"], "res": res["res"], "max_duty": res["max_duty"]}
+
+    def set_pwm_config(self, freq: int, res_bit: int) -> bool:
+        """PWMの周波数と分解能を動的に変更"""
+        res = self.command(protocol.CMD_SET_PWM_CONFIG, freq=freq, res=res_bit)
+        return res.get("status") == "ok"
+
+    def set_rgb(self, r: int, g: int, b: int, brightness: Optional[int] = None) -> bool:
+        """内蔵RGB LEDの制御"""
+        if any(not (0 <= c <= 255) for c in (r, g, b)):
+            raise ValueError("RGB values must be between 0 and 255")
+        kwargs = {"r": r, "g": g, "b": b}
+        if brightness is not None:
+            kwargs["brightness"] = brightness
+        res = self.command(protocol.CMD_SET_RGB, **kwargs)
+        return res.get("status") == "ok"
+
+    def led_off(self) -> bool:
+        """RGB LEDの消灯"""
+        res = self.command(protocol.CMD_LED_OFF)
+        return res.get("status") == "ok"
+
+    def set_led_mode(self, mode: Literal["status", "manual"]) -> bool:
+        """LEDの動作モードを設定 ('status' または 'manual')"""
+        res = self.command(protocol.CMD_SET_LED_MODE, mode=mode)
+        return res.get("status") == "ok"
+
+    def get_led_state(self) -> Dict[str, Any]:
+        """現在のLED設定値を取得"""
+        return self.command(protocol.CMD_GET_LED_STATE)
+
+    def help(self) -> List[str]:
+        """デバイスがサポートするコマンド一覧を取得"""
+        res = self.command(protocol.CMD_HELP)
+        return res.get("commands", [])
+
+    def i2c_scan(self) -> List[int]:
+        """I2C バスをスキャンし、応答のあったデバイスのアドレス一覧を返す"""
+        res = self.command(protocol.CMD_I2C_SCAN)
+        return res.get("devices", [])
+
+    def i2c_read(self, addr: int, length: int) -> List[int]:
+        """I2C デバイスからデータを読み取る"""
+        if not isinstance(addr, int) or not isinstance(length, int):
+            raise ValueError("addr and length must be integers")
+        res = self.command(protocol.CMD_I2C_READ, addr=addr, len=length)
+        data = res.get("data")
+        if not isinstance(data, list):
+            raise ESP32IOProtocolError(f"Invalid i2c_read response: {res}")
+        return data
+
+    def i2c_write(self, addr: int, data: List[int]) -> bool:
+        """I2C デバイスにデータを書き込む"""
+        if not isinstance(addr, int) or not isinstance(data, list):
+            raise ValueError("addr must be int and data must be a list of integers")
+        res = self.command(protocol.CMD_I2C_WRITE, addr=addr, data=data)
+        return res.get("status") == "ok"
+
+    def get_sensors(self) -> Dict[str, Any]:
+        """BME280, MPU6050, VL53L1X などの接続済みセンサー値を一括取得"""
+        return self.command(protocol.CMD_GET_SENSORS)
+
+    def set_oled(self, text: str, x: int = 0, y: int = 0, size: int = 1, clear: bool = True) -> bool:
+        """SSD1306 OLED ディスプレイにテキストを表示"""
+        res = self.command(protocol.CMD_SET_OLED, text=text, x=x, y=y, size=size, clear=clear)
+        return res.get("status") == "ok"
+
+    # ------------------------------------------------------------------
+    # 個別エンティティの直接publish (応答待ちなし。Home Assistant側の操作と同等)
+    # ------------------------------------------------------------------
+    def publish_do(self, pin_id: int, value: int) -> None:
+        """`<base>/do/<pin_id>/set` へ直接publishする（応答は待たない）"""
+        if value not in (0, 1):
+            raise ValueError("value must be 0 or 1")
+        self._client.publish(f"{self.base}/do/{pin_id}/set", "ON" if value else "OFF")
+
+    def publish_pwm(self, pin_id: int, duty: int) -> None:
+        """`<base>/pwm/<pin_id>/set` へ直接publishする（応答は待たない）"""
+        if duty < 0:
+            raise ValueError("duty must be 0 or greater")
+        self._client.publish(f"{self.base}/pwm/{pin_id}/set", str(duty))
+
+    def publish_rgb(self, r: int, g: int, b: int, brightness: Optional[int] = None) -> None:
+        """`<base>/rgb/set` へ直接publishする（応答は待たない）"""
+        if any(not (0 <= c <= 255) for c in (r, g, b)):
+            raise ValueError("RGB values must be between 0 and 255")
+        payload: Dict[str, Any] = {"state": "ON", "color": {"r": r, "g": g, "b": b}}
+        if brightness is not None:
+            payload["brightness"] = brightness
+        self._client.publish(f"{self.base}/rgb/set", json.dumps(payload))
+
+    def publish_led_off(self) -> None:
+        """`<base>/rgb/set` へ消灯を直接publishする（応答は待たない）"""
+        self._client.publish(f"{self.base}/rgb/set", json.dumps({"state": "OFF"}))
+
+    def publish_led_mode(self, mode: Literal["status", "manual"]) -> None:
+        """`<base>/led_mode/set` へ直接publishする（応答は待たない）"""
+        if mode not in ("status", "manual"):
+            raise ValueError('mode must be "status" or "manual"')
+        self._client.publish(f"{self.base}/led_mode/set", mode)
+
+    def publish_oled(self, text: str) -> None:
+        """`<base>/oled/set` へ直接publishする（応答は待たない）"""
+        self._client.publish(f"{self.base}/oled/set", text)
+
+    # ------------------------------------------------------------------
+    def close(self):
+        """MQTT接続を終了する"""
+        self._client.loop_stop()
+        self._client.disconnect()
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass

esp32io_mqtt-0.1.0/esp32io_mqtt/exceptions.py

@@ -0,0 +1,19 @@
+class ESP32IOError(Exception):
+    """esp32io_mqtt ライブラリの基底例外"""
+    pass
+
+class ESP32IODeviceError(ESP32IOError):
+    """ESP32 が status=error を返したときの例外 (ロジックエラー)"""
+    pass
+
+class ESP32IOMqttError(ESP32IOError, RuntimeError):
+    """MQTTブローカーとの接続・通信に失敗したときの例外"""
+    pass
+
+class ESP32IOTimeoutError(ESP32IOMqttError):
+    """cmd/result 応答の待機がタイムアウトしたときの例外"""
+    pass
+
+class ESP32IOProtocolError(ESP32IOError, RuntimeError):
+    """デバイスから不正な JSON や予期しない応答が返ったときの例外"""
+    pass

esp32io_mqtt-0.1.0/esp32io_mqtt/protocol.py

@@ -0,0 +1,68 @@
+"""ESP32IO-MQTT プロトコル定義
+
+ベーストピックは `<topic_root>/<device_id>` (既定 topic_root="esp32io")。
+汎用JSONコマンドチャネルは `<base>/cmd` に送信し、`<base>/cmd/result` で応答を受け取る。
+個別エンティティのトピックは ENTITY_TOPICS を参照。
+"""
+
+DEFAULT_TOPIC_ROOT = "esp32io"
+
+# --- 汎用JSONコマンドチャネル (esp32io/<device_id>/cmd -> cmd/result) ---
+CMD_PING = "ping"
+CMD_GET_STATUS = "get_status"
+CMD_GET_IO_STATE = "get_io_state"
+CMD_READ_DI = "read_di"
+CMD_SET_DO = "set_do"
+CMD_READ_ADC = "read_adc"
+CMD_SET_PWM = "set_pwm"
+CMD_GET_PWM_CONFIG = "get_pwm_config"
+CMD_SET_PWM_CONFIG = "set_pwm_config"
+CMD_SET_RGB = "set_rgb"
+CMD_LED_OFF = "led_off"
+CMD_SET_LED_MODE = "set_led_mode"
+CMD_GET_LED_STATE = "get_led_state"
+CMD_HELP = "help"
+CMD_I2C_SCAN = "i2c_scan"
+CMD_I2C_READ = "i2c_read"
+CMD_I2C_WRITE = "i2c_write"
+CMD_GET_SENSORS = "get_sensors"
+CMD_SET_OLED = "set_oled"
+
+ALL_COMMANDS = (
+    CMD_PING,
+    CMD_GET_STATUS,
+    CMD_GET_IO_STATE,
+    CMD_READ_DI,
+    CMD_SET_DO,
+    CMD_READ_ADC,
+    CMD_SET_PWM,
+    CMD_GET_PWM_CONFIG,
+    CMD_SET_PWM_CONFIG,
+    CMD_SET_RGB,
+    CMD_LED_OFF,
+    CMD_SET_LED_MODE,
+    CMD_GET_LED_STATE,
+    CMD_HELP,
+    CMD_I2C_SCAN,
+    CMD_I2C_READ,
+    CMD_I2C_WRITE,
+    CMD_GET_SENSORS,
+    CMD_SET_OLED,
+)
+
+# --- 個別エンティティ (Home Assistant MQTT Discovery互換) のトピック購読パターン ---
+# "<base>" を実際のベーストピックに置換して subscribe/publish する。
+ENTITY_SUBSCRIBE_TOPICS = (
+    "{base}/status",
+    "{base}/di/+/state",
+    "{base}/do/+/state",
+    "{base}/adc/+/state",
+    "{base}/pwm/+/state",
+    "{base}/rgb/state",
+    "{base}/led_mode/state",
+    "{base}/oled/state",
+    "{base}/bme280/#",
+    "{base}/mpu6050/#",
+    "{base}/vl53l1x/#",
+    "{base}/diag/#",
+)

esp32io_mqtt-0.1.0/esp32io_mqtt.egg-info/PKG-INFO

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: esp32io-mqtt
+Version: 0.1.0
+Summary: A lightweight Python MQTT client for controlling ESP32IO-MQTT devices (Home Assistant compatible).
+Author: Noritama-Lab
+License: MIT
+Project-URL: Repository, https://github.com/Noritama-Lab/esp32io-mqtt-api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT 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 :: System :: Hardware
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paho-mqtt<2.0,>=1.6
+Dynamic: license-file
+
+# ESP32IO-MQTT Python MQTT Client
+
+ESP32IO-MQTT is a lightweight Python **MQTT** client for controlling [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware) devices.
+
+日本語 / English
+
+---
+
+## 日本語
+
+ESP32IO-MQTT Pythonクライアントは、**MQTTブローカー** 経由で ESP32IO-MQTT ファームウェアを制御するための軽量Pythonクライアントです。
+
+ESP32IO-MQTT ファームウェアはデバイス制御を **MQTT** 経由で行います。本クライアントもMQTT専用です。
+
+---
+
+## 特徴
+
+- MQTTブローカー経由での接続のみをサポート（HTTP/シリアルは非対応）
+- 汎用JSONコマンドチャネル (`<base>/cmd` → `<base>/cmd/result`) を使った同期API (`read_di()`, `set_do()`, `get_io_state()` 等)
+- 個別エンティティのトピック (Home Assistant MQTT Discovery互換) にも対応
+  - `get_cached_state()` で直近受信した状態のスナップショットを取得
+  - `on_state_change()` で状態変化のコールバックを登録
+  - `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()` で応答待ちなしに直接publish
+- I2Cスキャン、リード/ライト、BME280/MPU6050/VL53L1Xなどのセンサー一括取得、OLED表示をサポート
+- PWM周波数・分解能の取得/更新に対応
+- 通信エラー・タイムアウト・プロトコル不整合・デバイスエラーなど統一例外を定義
+- 任意JSONを送れる低レベルAPI `command()` を提供
+
+---
+
+## 動作環境
+
+- Python 3.8 以上
+- `paho-mqtt>=1.6,<2.0`
+- MQTTブローカー (Mosquitto等)
+- ESP32IO-MQTT ファームウェア（MQTT対応）
+
+---
+
+## インストール
+
+```bash
+pip install -r requirements.txt
+# または
+pip install -e .
+```
+
+---
+
+## クイックスタート
+
+```python
+from esp32io_mqtt import ESP32S3IOMqtt
+
+# DEVICE_ID は設定ポータル (http://<device_ip>/) のページタイトルや
+# mDNSホスト名 (ESP32IO_MQTT_XXXXXX) で確認できます。
+with ESP32S3IOMqtt("ESP32IO_MQTT_XXXXXX", "192.168.1.5", debug=False) as esp:
+    print("ping =", esp.ping())
+    print("di0 =", esp.read_di(0))
+    print("adc0 =", esp.read_adc(0))
+    print("pwm config =", esp.get_pwm_config())
+
+    esp.set_do(0, 1)
+    esp.set_pwm(0, 128)
+
+    print(esp.get_io_state())
+```
+
+サンプル実行:
+
+```bash
+py -m examples.mqtt_example
+```
+
+---
+
+## 通信方式
+
+### 1. 汎用JSONコマンドチャネル (同期API)
+
+`command()` および `read_di()` / `set_do()` などの高レベルメソッドは、`<base>/cmd` にJSONをpublishし `<base>/cmd/result` の応答を待つ同期方式です。戻り値やエラー(`ESP32IODeviceError`)で結果を確認できます。
+
+### 2. 個別エンティティのトピック (Home Assistant MQTT Discovery互換)
+
+接続時に `di/+/state` `do/+/state` `pwm/+/state` `rgb/state` `led_mode/state` `oled/state` `bme280/#` `mpu6050/#` `vl53l1x/#` `diag/#` `status` を自動的にsubscribeし、受信するたびに内部キャッシュへ保存します。
+
+- `get_cached_state()` — 直近に受信した値のスナップショット (dict) を取得
+- `on_state_change(callback)` — 状態トピックを受信するたびに `callback(topic_suffix, payload)` を呼び出す
+- `is_online` — LWTトピック (`<base>/status`) が `online` かどうか
+- `publish_do(pin_id, value)` / `publish_pwm(pin_id, duty)` / `publish_rgb(r, g, b, brightness)` / `publish_led_off()` / `publish_led_mode(mode)` / `publish_oled(text)` — 応答を待たずに直接publish（Home Assistant側からの操作と同じ経路）
+
+---
+
+## API 一覧（主要メソッド）
+
+- `ESP32S3IOMqtt(device_id, host, port=1883, user=None, password=None, topic_root="esp32io", keepalive=30, cmd_timeout=5.0, connect_timeout=10.0, debug=False)`
+- `ping()`
+- `read_di(pin_id)` / `set_do(pin_id, value)`
+- `read_adc(pin_id)`
+- `set_pwm(pin_id, duty)`
+- `get_pwm_config()` / `set_pwm_config(freq, res)`
+- `set_led_mode(mode)` / `set_rgb(r, g, b, brightness)` / `led_off()` / `get_led_state()`
+- `i2c_scan()` / `i2c_read(addr, length)` / `i2c_write(addr, data)`
+- `get_sensors()`
+- `set_oled(text, x, y, size, clear)`
+- `get_io_state()` / `get_status()`
+- `command(cmd, **kwargs)`
+- `help()`
+- `get_cached_state()` / `on_state_change(callback)` / `is_online`
+- `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()`
+- `close()`
+
+---
+
+## 例外
+
+- `ESP32IOError`（基底クラス）
+- `ESP32IOMqttError` — ブローカー接続・publish失敗
+- `ESP32IOTimeoutError` — `cmd/result` 応答待ちのタイムアウト（`ESP32IOMqttError`のサブクラス）
+- `ESP32IOProtocolError` — デバイスから不正な応答
+- `ESP32IODeviceError` — デバイスが `status=error` を返した場合
+
+---
+
+## プロジェクト構成
+
+```text
+.
+├── esp32io_mqtt/
+│   ├── __init__.py
+│   ├── client.py
+│   ├── exceptions.py
+│   └── protocol.py
+├── examples/
+│   ├── mqtt_example.py
+│   └── i2c_example.py
+├── pyproject.toml
+├── requirements.txt
+├── LICENSE
+└── README.md
+```
+
+---
+
+## ファームウェア
+
+対応ファームウェア: [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware)（MQTT + Home Assistant MQTT Discovery対応）。
+トピック構成・汎用JSONコマンド一覧は同リポジトリの `COMMAND_REFERENCE.md` を参照してください。
+
+---
+
+## ライセンス
+
+MIT License
+Copyright (c) 2026 Noritama-Lab
+
+---
+
+## English
+
+ESP32IO-MQTT Python client is a lightweight **MQTT** client for controlling [ESP32IO-MQTT](https://github.com/Noritama-Lab/esp32io-mqtt-firmware) firmware.
+
+ESP32IO-MQTT firmware controls devices over **MQTT**. This client is MQTT-only.
+
+### Features
+
+- MQTT broker connection only (no HTTP/Serial support)
+- Synchronous API over the generic JSON command channel (`<base>/cmd` → `<base>/cmd/result`) (`read_di()`, `set_do()`, `get_io_state()`, etc.)
+- Support for individual entity topics (Home Assistant MQTT Discovery compatible)
+  - `get_cached_state()` for a snapshot of the latest received state
+  - `on_state_change()` to register a callback for state changes
+  - `publish_do()` / `publish_pwm()` / `publish_rgb()` / `publish_led_off()` / `publish_led_mode()` / `publish_oled()` to publish directly without waiting for a response
+- I2C scanning, raw read/write, sensor batch reads (BME280/MPU6050/VL53L1X), and OLED control
+- PWM frequency/resolution read & update
+- Unified exceptions for MQTT, protocol, timeout, and device errors
+- Low-level `command()` API for custom JSON commands
+
+### Requirements
+
+- Python 3.8+
+- `paho-mqtt>=1.6,<2.0`
+- An MQTT broker (e.g. Mosquitto)
+- ESP32IO-MQTT firmware (MQTT-based)
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+# or
+pip install -e .
+```
+
+### Quick Start
+
+```python
+from esp32io_mqtt import ESP32S3IOMqtt
+
+with ESP32S3IOMqtt("ESP32IO_MQTT_XXXXXX", "192.168.1.5", debug=False) as esp:
+    print("ping =", esp.ping())
+    print("di0 =", esp.read_di(0))
+    esp.set_do(0, 1)
+    print(esp.get_io_state())
+```
+
+### License
+
+MIT License
+Copyright (c) 2026 Noritama-Lab

esp32io_mqtt-0.1.0/esp32io_mqtt.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+esp32io_mqtt/__init__.py
+esp32io_mqtt/client.py
+esp32io_mqtt/exceptions.py
+esp32io_mqtt/protocol.py
+esp32io_mqtt/py.typed
+esp32io_mqtt.egg-info/PKG-INFO
+esp32io_mqtt.egg-info/SOURCES.txt
+esp32io_mqtt.egg-info/dependency_links.txt
+esp32io_mqtt.egg-info/requires.txt
+esp32io_mqtt.egg-info/top_level.txt

esp32io_mqtt-0.1.0/esp32io_mqtt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

esp32io_mqtt-0.1.0/esp32io_mqtt.egg-info/requires.txt

@@ -0,0 +1 @@
+paho-mqtt<2.0,>=1.6

esp32io_mqtt-0.1.0/esp32io_mqtt.egg-info/top_level.txt

@@ -0,0 +1 @@
+esp32io_mqtt

esp32io_mqtt-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "esp32io-mqtt"
+version = "0.1.0"
+description = "A lightweight Python MQTT client for controlling ESP32IO-MQTT devices (Home Assistant compatible)."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Noritama-Lab"},
+]
+dependencies = [
+    "paho-mqtt>=1.6,<2.0",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Hardware",
+]
+
+[project.urls]
+Repository = "https://github.com/Noritama-Lab/esp32io-mqtt-api"
+
+[tool.setuptools.packages.find]
+include = ["esp32io_mqtt"]
+exclude = ["examples*", "tests*"]
+
+[tool.setuptools.package-data]
+esp32io_mqtt = ["py.typed"]

esp32io_mqtt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+