meshcore 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

meshcore/commands/base.py

@@ -122,7 +122,7 @@ class CommandHandlerBase:
             # Create an error event when no event is received
             return Event(EventType.ERROR, {"reason": "no_event_received"})
         except asyncio.TimeoutError:
-            logger.debug(f"Command timed out {data}")
+            logger.debug(f"Command timed out waiting for events {expected_events}")
             return Event(EventType.ERROR, {"reason": "timeout"})
         except Exception as e:
             logger.debug(f"Command error: {e}")

meshcore/commands/device.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from hashlib import sha256
 from typing import Optional
@@ -206,6 +207,72 @@ class DeviceCommands(CommandHandlerBase):
         logger.debug("Requesting private key export")
         return await self.send(b"\x17", [EventType.PRIVATE_KEY, EventType.DISABLED, EventType.ERROR])
 
+    async def import_private_key(self, key) -> Event:
+        logger.debug("Requesting private key import")
+        data = b"\x18" + key
+        return await self.send(data, [EventType.OK, EventType.ERROR])
+
+    async def sign_start(self) -> Event:
+        logger.debug("Starting signing session on device")
+        return await self.send(b"\x21", [EventType.SIGN_START, EventType.ERROR])
+
+    async def sign_data(self, chunk: bytes) -> Event:
+        if not isinstance(chunk, (bytes, bytearray)):
+            raise TypeError("chunk must be bytes-like")
+        logger.debug(f"Sending signing data chunk ({len(chunk)} bytes)")
+        data = b"\x22" + bytes(chunk)
+        result = await self.send(data, [EventType.OK, EventType.ERROR], timeout=5.0)
+        
+        # If we got an error (not just timeout), return it immediately
+        if result.type == EventType.ERROR:
+            # If it's a timeout/no_event, log a warning but continue - the data may have been received
+            if result.payload.get("reason") in ("timeout", "no_event_received"):
+                logger.warning(
+                    f"sign_data OK response not received (timeout), but continuing - "
+                    f"data may have been processed by device"
+                )
+                return Event(EventType.OK, {})
+            # For actual errors (bad state, table full, etc.), return the error
+            return result
+        
+        return result
+
+    async def sign_finish(self, timeout: Optional[float] = None, data_size: int = 0) -> Event:
+        logger.debug("Finalizing signing session on device")
+        if timeout is None:
+            base_timeout = max(self.default_timeout * 3, 15.0)
+            size_bonus = min(data_size / 2048.0, 5.0)
+            timeout = base_timeout + size_bonus
+        logger.debug(f"sign_finish using timeout={timeout:.1f} seconds (data_size={data_size} bytes)")
+        return await self.send(b"\x23", [EventType.SIGNATURE, EventType.ERROR], timeout=timeout)
+
+    async def sign(self, data: bytes, chunk_size: int = 120, timeout: Optional[float] = None) -> Event:
+        if not isinstance(data, (bytes, bytearray)):
+            raise TypeError("data must be bytes-like")
+        if chunk_size <= 0:
+            raise ValueError("chunk_size must be > 0")
+
+        start_evt = await self.sign_start()
+        if start_evt.type == EventType.ERROR:
+            return start_evt
+
+        max_len = start_evt.payload.get("max_length", 0)
+        if max_len and len(data) > max_len:
+            return Event(EventType.ERROR, {"reason": "data_too_large", "max_length": max_len, "len": len(data)})
+
+        for idx in range(0, len(data), chunk_size):
+            chunk = data[idx : idx + chunk_size]
+            chunk_num = (idx // chunk_size) + 1
+            total_chunks = (len(data) + chunk_size - 1) // chunk_size
+            logger.debug(f"Sending chunk {chunk_num}/{total_chunks} ({len(chunk)} bytes)")
+            evt = await self.sign_data(chunk)
+            if evt.type == EventType.ERROR:
+                logger.error(f"Error sending chunk {chunk_num}/{total_chunks}: {evt.payload}")
+                return evt
+            logger.debug(f"Chunk {chunk_num}/{total_chunks} sent successfully")
+
+        return await self.sign_finish(timeout=timeout, data_size=len(data))
+
     async def get_stats_core(self) -> Event:
         logger.debug("Getting core statistics")
         # CMD_GET_STATS (56) + STATS_TYPE_CORE (0)

meshcore/events.py

@@ -50,6 +50,8 @@ class EventType(Enum):
     CONTROL_DATA = "control_data"
     DISCOVER_RESPONSE = "discover_response"
     NEIGHBOURS_RESPONSE = "neighbours_response"
+    SIGN_START = "sign_start"
+    SIGNATURE = "signature"
 
     # Command response types
     OK = "command_ok"

meshcore/reader.py

@@ -710,6 +710,20 @@ class MessageReader:
             else:
                 logger.error(f"Invalid private key response length: {len(data)}")
 
+        elif packet_type_value == PacketType.SIGN_START.value:
+            logger.debug(f"Received sign start response: {data.hex()}")
+            # Payload: 1 reserved byte, 4-byte max length
+            dbuf.read(1)
+            max_len = int.from_bytes(dbuf.read(4), "little")
+            res = {"max_length": max_len}
+            await self.dispatcher.dispatch(Event(EventType.SIGN_START, res))
+
+        elif packet_type_value == PacketType.SIGNATURE.value:
+            logger.debug(f"Received signature: {data.hex()}")
+            signature = dbuf.read()
+            res = {"signature": signature}
+            await self.dispatcher.dispatch(Event(EventType.SIGNATURE, res))
+
         elif packet_type_value == PacketType.DISABLED.value:
             logger.debug("Received disabled response")
             res = {"reason": "private_key_export_disabled"}

{meshcore-2.2.2.dist-info → meshcore-2.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.2.2
+Version: 2.2.4
 Summary: Base classes for communicating with meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore_py
 Project-URL: Issues, https://github.com/fdlamotte/meshcore_py/issues
@@ -490,6 +490,8 @@ All events in MeshCore are represented by the `EventType` enum. These events are
 | `LOG_DATA` | `"log_data"` | Generic log data | Various log information |
 | **Binary Protocol Events** |||
 | `BINARY_RESPONSE` | `"binary_response"` | Generic binary response | Tag and hex data |
+| `SIGN_START` | `"sign_start"` | Start of an on-device signing session | Maximum buffer size (bytes) for data to sign |
+| `SIGNATURE` | `"signature"` | Resulting on-device signature | Raw signature bytes |
 | **Authentication Events** |||
 | `LOGIN_SUCCESS` | `"login_success"` | Successful login | Permissions, admin status, pubkey prefix |
 | `LOGIN_FAILED` | `"login_failed"` | Failed login attempt | Pubkey prefix |
@@ -586,6 +588,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `req_telemetry(contact, timeout=0)` | `contact: dict, timeout: float` | `TELEMETRY_RESPONSE` | Get telemetry via binary protocol |
 | `req_mma(contact, start, end, timeout=0)` | `contact: dict, start: int, end: int, timeout: float` | `MMA_RESPONSE` | Get historical telemetry data |
 | `req_acl(contact, timeout=0)` | `contact: dict, timeout: float` | `ACL_RESPONSE` | Get access control list |
+| `sign_start()` | None | `SIGN_START` | Begin a signing session; returns maximum buffer size for data to sign |
+| `sign_data(chunk)` | `chunk: bytes` | `OK` | Append a data chunk to the current signing session (can be called multiple times) |
+| `sign_finish()` | None | `SIGNATURE` | Finalize signing and return the signature for all accumulated data |
 
 ### Helper Methods
 
@@ -593,6 +598,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 |--------|---------|-------------|
 | `get_contact_by_name(name)` | `dict/None` | Find contact by advertisement name |
 | `get_contact_by_key_prefix(prefix)` | `dict/None` | Find contact by partial public key |
+| `sign(data, chunk_size=512)` | `Event` (`SIGNATURE`/`ERROR`) | High-level helper to sign arbitrary data on-device, handling chunking for you |
 | `is_connected` | `bool` | Check if device is currently connected |
 | `subscribe(event_type, callback, filters=None)` | `Subscription` | Subscribe to events with optional filtering |
 | `unsubscribe(subscription)` | None | Remove event subscription |
@@ -632,6 +638,8 @@ Check the `examples/` directory for more:
 - `pubsub_example.py`: Event subscription system with auto-fetching
 - `serial_infos.py`: Quick device info retrieval
 - `serial_msg.py`: Message sending and receiving
+- `serial_pingbot.py`: Ping bot which can be run on a channel
+- `serial_meshcore_ollama.py`: Simple Ollama to Meshcore gateway, a simple chat box 
 - `ble_pin_pairing_example.py`: BLE connection with PIN pairing
 - `ble_private_key_export.py`: BLE private key export with PIN authentication
 - `ble_t1000_infos.py`: BLE connections

{meshcore-2.2.2.dist-info → meshcore-2.2.4.dist-info}/RECORD

@@ -1,22 +1,22 @@
 meshcore/__init__.py,sha256=55PdT8gZ9Lf727s7BdSuCt3lIBlAhRzX28A8i0DHaRc,602
 meshcore/ble_cx.py,sha256=S5uanBI88Mxwcs1zWbdQGVJ6GC4kdWz8-Z_2aQVpeGI,6864
 meshcore/connection_manager.py,sha256=3U0TWuHDvL5FfwEwXRy5HjlCyV3nsWhhrEC7TVxFzZI,5899
-meshcore/events.py,sha256=w1Ug5ugO2hAcMs7cV3WRi_4-hv0Lw_Y7NuZzZv0LPl8,8238
+meshcore/events.py,sha256=7LFVxsF_U2rdS2ZfNl9QsgYOqQh3rYHYKV50LLg3wkg,8296
 meshcore/lpp_json_encoder.py,sha256=vyn7z3VYWOo_B9xmCzqblh5xCa0QKWKcMi2eOqw18RE,1875
 meshcore/meshcore.py,sha256=n8fH7AEx7DR8BHOYL_Qex9ns6ACKklNNqYbPnNnvqyE,16110
 meshcore/packets.py,sha256=3irQww-HBAe_O03oHPAdp8Z6pwenjsVX_u3F19fHKyc,1294
 meshcore/parsing.py,sha256=48PQkig-sqvsRlkF9zkvWhJoSq6ERCbGb_aRuCND5NI,4044
-meshcore/reader.py,sha256=YNCP4-ll5JEKW6cvbRMfjFLdG4RtVKt-npEDr8hnpwM,33939
+meshcore/reader.py,sha256=1fYsTODW8csC2NxntXHACC4SJv7PlSjtUEazLCcbfTs,34618
 meshcore/serial_cx.py,sha256=-kaqnqk7Ydufu2DECFfPDv4Xs-7gHUBuz8v0xf8fvvE,3969
 meshcore/tcp_cx.py,sha256=05YRVMnjY5aVBTJcHa0uG4VfFKGbV6hQ1pPIsJg4CDI,4227
 meshcore/commands/__init__.py,sha256=qfGPzrha7pZQYHOXLZyDsK-QVRjiz5zxAEj8kMxO9uU,536
-meshcore/commands/base.py,sha256=yKfKSmdnIh0DhAZ34TtioE38huxXc0QGB5Hm_wbcOqg,7398
+meshcore/commands/base.py,sha256=78_fyKb80Rg4xr_-MRakSh5x2d2dJFwV9db86cQ4iGo,7428
 meshcore/commands/binary.py,sha256=MihRjG4IppPYPeu2KMpctcBPac_hdClp6PgGirQfydg,8412
 meshcore/commands/contact.py,sha256=7X4e17M2YxUZsfUhaN18XZG2inTuXknXJOBAoPblydw,5880
 meshcore/commands/control_data.py,sha256=sXp1RoEw6Z0zPr0Nn5XBovEY6r9sePbWQwsbY0iYyXc,1512
-meshcore/commands/device.py,sha256=Ub8sS0xtJu3TJwENyswk8lYmYorMH3W33ppHEpSNpoU,9437
+meshcore/commands/device.py,sha256=LEMEOQyJIcDNh5fBgX9GmFiD2AWTFhm3qaY7MTpQ5Es,12754
 meshcore/commands/messaging.py,sha256=Mglog1xCz_DhKJU1vEv0AD7bBo5_OhEul1MpSY7dnXc,9806
-meshcore-2.2.2.dist-info/METADATA,sha256=rgQoS5tlPN59QZPkaYmKja9Ah_M3pt0g95Xt_D7VlwE,25316
-meshcore-2.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meshcore-2.2.2.dist-info/licenses/LICENSE,sha256=o62-JWT_C-ZqEtzb1Gl_PPtPr0pVT8KDmgji_Y_bejI,1075
-meshcore-2.2.2.dist-info/RECORD,,
+meshcore-2.2.4.dist-info/METADATA,sha256=MCwlYln0nWR6L_kVUp-M5y_ToMN4O31UaGO1O40KK1Q,26169
+meshcore-2.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+meshcore-2.2.4.dist-info/licenses/LICENSE,sha256=o62-JWT_C-ZqEtzb1Gl_PPtPr0pVT8KDmgji_Y_bejI,1075
+meshcore-2.2.4.dist-info/RECORD,,

{meshcore-2.2.2.dist-info → meshcore-2.2.4.dist-info}/WHEEL

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