meshcore 2.3.14__tar.gz → 2.3.16__tar.gz

{meshcore-2.3.14 → meshcore-2.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: meshcore
-Version: 2.3.14
+Version: 2.3.16
 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

{meshcore-2.3.14 → meshcore-2.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore"
-version = "2.3.14"
+version = "2.3.16"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
   { name="Alex Wolden", email="awolden@gmail.com" },

{meshcore-2.3.14 → meshcore-2.3.16}/src/meshcore/commands/messaging.py

@@ -19,6 +19,7 @@ class MessagingCommands(CommandHandlerBase):
             [
                 EventType.CONTACT_MSG_RECV,
                 EventType.CHANNEL_MSG_RECV,
+                EventType.CHANNEL_DATA_RECV,
                 EventType.ERROR,
                 EventType.NO_MORE_MSGS,
             ],
@@ -327,7 +328,7 @@ class MessagingCommands(CommandHandlerBase):
                 return Event(EventType.ERROR, {"reason": "unsupported_path_type"})
 
         # Prepare the command packet: CMD(1) + tag(4) + auth_code(4) + flags(1) + [path]
-        cmd_data = bytearray([36])  # CMD_SEND_TRACE_PATH
+        cmd_data = bytearray([CommandType.SEND_TRACE_PATH.value])  # CMD_SEND_TRACE_PATH
         cmd_data.extend(tag.to_bytes(4, "little"))
         cmd_data.extend(auth_code.to_bytes(4, "little"))
         cmd_data.append(flags)
@@ -365,7 +366,46 @@ class MessagingCommands(CommandHandlerBase):
         if len(payload) < 4:
             raise ValueError("payload must be at least 4 bytes")
         path = bytes(path)
-        data = bytes([0x19, len(path)]) + path + bytes(payload)
+        data = bytes([CommandType.SEND_RAW_DATA.value, len(path)]) + path + bytes(payload)
+        return await self.send(data, [EventType.OK, EventType.ERROR])
+
+    async def send_channel_data(
+        self, chan: int, data_type: int, payload: bytes,
+        path: Optional[bytes] = None, path_hash_mode: Optional[int] = 0
+    ) -> Event:
+        """Send a binary datagram to a channel via CMD_SEND_CHANNEL_DATA (0x3E).
+
+        Command format:
+            0x3E | channel_idx(1) | path_len(1) | path(path_len bytes) | data_type(2, LE) | payload
+
+        Args:
+            chan:      Channel index (0-255, must fit in one byte; the firmware rejects unknown channels).
+            data_type: Application identifier, 0x0001-0xFFFF (0xFFFF is the developer namespace).
+            payload:   Binary payload, at most 163 bytes (MAX_CHANNEL_DATA_LENGTH).
+            path:      Optional path bytes to send along (default None = flood, path_len 0xFF).
+            path_hash_mode: Optional path_hash_mode (size of the hash - 1)
+
+        Returns:
+            Event with OK or ERROR.
+        """
+        if not isinstance(payload, (bytes, bytearray)):
+            raise TypeError("payload must be bytes-like")
+        if not 0 <= chan <= 0xFF:
+            raise ValueError("chan must fit in one byte (0-255)")
+        if not 0x0001 <= data_type <= 0xFFFF:
+            raise ValueError("data_type must be between 0x0001 and 0xFFFF")
+        if len(payload) > 163:
+            raise ValueError("payload must be at most 163 bytes")
+        if path is None:
+            path_bytes = b"\xff"
+        else:
+            path = bytes(path)
+            if len(path) >= 0xFF:
+                raise ValueError("path must be shorter than 255 bytes")
+            path_len = int(len(path) / (path_hash_mode + 1))
+            path_bytes = bytes([path_len | (path_hash_mode << 6)]) + path
+        logger.debug(f"Sending raw data {payload.hex()} through path {"Flood" if path is None else path.hex()} of len {"-1" if path is None else path_len} with mode {path_hash_mode} (raw path: {path_bytes.hex()})")
+        data = bytes([CommandType.SEND_CHANNEL_DATA.value, chan]) + path_bytes + data_type.to_bytes(2, "little") + bytes(payload)
         return await self.send(data, [EventType.OK, EventType.ERROR])
 
     async def set_flood_scope(self, scope, force_unscoped=False):

{meshcore-2.3.14 → meshcore-2.3.16}/src/meshcore/lpp_json_encoder.py

@@ -25,7 +25,7 @@ my_lpp_types = {
     128: ("power", []),
     130: ("distance", []),
     131: ("energy", []),
-    132: ("direction", None),
+    132: ("direction", []),
     133: ("time", []),
     134: ("gyrometer", None),
     135: ("colour", ["red", "green", "blue"]),

{meshcore-2.3.14 → meshcore-2.3.16}/src/meshcore/meshcore.py

@@ -207,11 +207,16 @@ class MeshCore:
 
     async def connect(self):
         await self.dispatcher.start()
-        result = await self.connection_manager.connect()
-        if result is None:
-            await self.dispatcher.stop()
-            raise ConnectionError("Failed to connect to device")
-        res = await self.commands.send_appstart(timeout=2)
+        try:
+            result = await self.connection_manager.connect()
+            if result is None:
+                raise ConnectionError("Failed to connect to device")
+            res = await self.commands.send_appstart(timeout=2)
+        except BaseException:
+            # The create_* factories drop this instance when connect() raises, so
+            # nothing else can stop the dispatcher task or close an opened transport.
+            await self.disconnect()
+            raise
         if res is None or res.type == EventType.ERROR:
             return None
         return res

{meshcore-2.3.14 → meshcore-2.3.16}/src/meshcore/packets.py

@@ -86,6 +86,7 @@ class CommandType(Enum):
     GET_ALLOWED_REPEAT_FREQ = 60
     GET_STATS = 56  # R04: CMD_GET_STATS — used by get_stats_core/radio/packets
     SET_PATH_HASH_MODE = 61
+    SEND_CHANNEL_DATA = 62
     SET_DEFAULT_FLOOD_SCOPE = 63
     GET_DEFAULT_FLOOD_SCOPE = 64
     SEND_RAW_PACKET = 65

{meshcore-2.3.14 → meshcore-2.3.16}/src/meshcore/reader.py

@@ -360,6 +360,7 @@ class MessageReader:
                     logger.debug(f"CHANNEL_DATA_RECV frame too short ({len(data)} bytes < 9), skipping parse")
                     return
                 res = {}
+                res["type"] = "DATA"
                 res["SNR"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True) / 4
                 dbuf.read(2)  # reserved
                 res["channel_idx"] = dbuf.read(1)[0]

{meshcore-2.3.14 → meshcore-2.3.16}/tests/unit/test_asyncio_lifecycle.py

@@ -4,9 +4,11 @@ Verification tests for asyncio lifecycle fixes.
 
 import asyncio
 import gc
+import socket
 import unittest
 from unittest.mock import AsyncMock, MagicMock, patch
 
+from meshcore import MeshCore
 from meshcore.events import Event, EventDispatcher, EventType
 from meshcore.tcp_cx import TCPConnection
 from meshcore.serial_cx import SerialConnection
@@ -231,5 +233,67 @@ class TestGetRunningLoop(unittest.TestCase):
         asyncio.run(_run())
 
 
+class TestConnectFailureCleanup(unittest.TestCase):
+    """A connect() that raises or is cancelled must not leave the dispatcher running."""
+
+    def setUp(self):
+        # Without collection, a leaked task stays visible instead of being destroyed
+        gc.disable()
+        self.addCleanup(gc.enable)
+
+    @staticmethod
+    def _dispatcher_tasks():
+        return [
+            task
+            for task in asyncio.all_tasks()
+            if not task.done()
+            and task.get_coro().__qualname__ == "EventDispatcher._process_events"
+        ]
+
+    def test_refused_create_tcp_leaves_no_dispatcher_task(self):
+        """create_tcp() raising on a refused connection stops the dispatcher."""
+        async def _run():
+            with socket.socket() as sock:
+                sock.bind(("127.0.0.1", 0))
+                port = sock.getsockname()[1]
+
+            with self.assertRaises(OSError):
+                await MeshCore.create_tcp("127.0.0.1", port)
+
+            assert self._dispatcher_tasks() == []
+
+        asyncio.run(_run())
+
+    def test_cancelled_connect_closes_transport_and_dispatcher(self):
+        """Cancelling connect() while it waits for appstart releases everything."""
+        async def _run():
+            peers = []
+            accepted = asyncio.Event()
+
+            async def accept(reader, _writer):
+                peers.append(reader)
+                accepted.set()
+
+            server = await asyncio.start_server(accept, "127.0.0.1", 0)
+            port = server.sockets[0].getsockname()[1]
+            try:
+                mc = MeshCore(TCPConnection("127.0.0.1", port))
+                attempt = asyncio.create_task(mc.connect())
+                await asyncio.wait_for(accepted.wait(), 1.0)
+                attempt.cancel()
+                with self.assertRaises(asyncio.CancelledError):
+                    await attempt
+
+                assert self._dispatcher_tasks() == []
+                assert not mc.dispatcher.running
+                # EOF on the server side means the client transport was closed
+                await asyncio.wait_for(peers[0].read(), 1.0)
+            finally:
+                server.close()
+                await server.wait_closed()
+
+        asyncio.run(_run())
+
+
 if __name__ == "__main__":
     unittest.main()

{meshcore-2.3.14 → meshcore-2.3.16}/tests/unit/test_lpp_parsing.py

@@ -37,3 +37,20 @@ class TestLppCurrentParsing:
         lpp = json.loads(json.dumps(LppFrame([lppdata]), default=lpp_json_encoder))
 
         assert lpp[0]['value'] == 0.5
+
+
+class TestLppDirectionParsing:
+    """Tests to verify LPP direction values are encoded as scalars."""
+
+    def test_direction_value_is_scalar(self):
+        """A direction value should not be serialized as a one-item list."""
+        from meshcore.lpp_json_encoder import lpp_json_encoder
+
+        # Channel 2, Type 132 (direction), 90 degrees = 0x00 0x5A.
+        raw_bytes = bytes([2, 132, 0x00, 0x5A])
+        lppdata = LppData.from_bytes(raw_bytes)
+
+        lpp = json.loads(json.dumps(LppFrame([lppdata]), default=lpp_json_encoder))
+
+        assert lpp[0]['type'] == 'direction'
+        assert lpp[0]['value'] == 90.0

{meshcore-2.3.14 → meshcore-2.3.16}/tests/unit/test_protocol_surface_gaps.py

@@ -12,6 +12,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 from meshcore.events import Event, EventType, EventDispatcher
 from meshcore.reader import MessageReader
 from meshcore.packets import PacketType, CommandType
+from meshcore.commands.messaging import MessagingCommands
 
 
 # ---------------------------------------------------------------------------
@@ -489,6 +490,121 @@ async def test_channel_data_recv_widened_data_type():
     assert evt.payload["payload"] == ""
 
 
+@pytest.mark.asyncio
+async def test_get_msg_returns_channel_data_recv():
+    """get_msg() resolves on CHANNEL_DATA_RECV instead of timing out.
+
+    The companion protocol lists PACKET_CHANNEL_DATA_RECV (0x1B) as an answer
+    to GET_MESSAGE (0x0A). When the next queued message is a channel datagram
+    the device answers with that frame, and get_msg() must return it rather
+    than an ERROR event with reason "timeout".
+    """
+    dispatcher = EventDispatcher()
+    await dispatcher.start()
+    reader = MessageReader(dispatcher)
+    commands = MessagingCommands()
+    commands.dispatcher = dispatcher
+
+    frame = bytes([
+        PacketType.CHANNEL_DATA_RECV.value,
+        0x10,              # SNR
+        0x00, 0x00,        # reserved
+        0x01,              # channel_idx
+        0xFF,              # path_len direct
+        0x23, 0x01,        # data_type = 0x0123 (little-endian)
+        0x04,              # data_len
+        0xDE, 0xAD, 0xBE, 0xEF,  # payload
+    ])
+
+    async def device(data):
+        # The device answers GET_MESSAGE with the queued channel datagram.
+        assert data == b"\x0a"
+        await reader.handle_rx(bytearray(frame))
+
+    commands._sender_func = device
+
+    try:
+        result = await commands.get_msg(timeout=2.0)
+    finally:
+        await dispatcher.stop()
+
+    assert result.type == EventType.CHANNEL_DATA_RECV
+    assert result.payload["channel_idx"] == 1
+    assert result.payload["data_type"] == 0x0123
+    assert result.payload["payload"] == "deadbeef"
+
+
+# ---------------------------------------------------------------------------
+# Command wrapper: send_channel_data (CMD_SEND_CHANNEL_DATA, 0x3E)
+# ---------------------------------------------------------------------------
+
+def _make_channel_data_commands():
+    """MessagingCommands whose send() records the written frame and expected events."""
+    from meshcore.commands.messaging import MessagingCommands
+
+    cmd = MessagingCommands.__new__(MessagingCommands)
+    sent = []
+
+    async def mock_send(data, expected_events, timeout=None):
+        sent.append((bytes(data), expected_events))
+        return Event(EventType.OK, {})
+
+    cmd.send = mock_send
+    return cmd, sent
+
+
+@pytest.mark.asyncio
+async def test_send_channel_data_flood_matches_protocol_example():
+    """Flood frame equals the companion protocol example: 3E 01 FF FF FF A1 B2 C3."""
+    cmd, sent = _make_channel_data_commands()
+
+    evt = await cmd.send_channel_data(1, 0xFFFF, b"\xA1\xB2\xC3")
+
+    assert evt.type == EventType.OK
+    assert sent == [
+        (bytes.fromhex("3E01FFFFFFA1B2C3"), [EventType.OK, EventType.ERROR]),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_send_channel_data_with_path():
+    """A path is sent after its length byte; data_type is little-endian."""
+    cmd, sent = _make_channel_data_commands()
+
+    await cmd.send_channel_data(2, 0x0102, b"\x07", path=b"\xAA\xBB")
+
+    assert sent[0][0] == bytes.fromhex("3E02" "02" "AABB" "0201" "07")
+
+
+@pytest.mark.asyncio
+async def test_send_channel_data_max_payload_accepted():
+    """A 163-byte payload (MAX_CHANNEL_DATA_LENGTH) is sent."""
+    cmd, sent = _make_channel_data_commands()
+
+    await cmd.send_channel_data(0, 0x0100, b"\x00" * 163)
+
+    assert len(sent[0][0]) == 3 + 2 + 163
+
+
+@pytest.mark.asyncio
+async def test_send_channel_data_rejects_invalid_arguments():
+    """Reserved data_type, oversized payload, bad chan and non-bytes payload never reach send()."""
+    cmd, sent = _make_channel_data_commands()
+
+    with pytest.raises(ValueError):
+        await cmd.send_channel_data(1, 0x0000, b"\x01")
+    with pytest.raises(ValueError):
+        await cmd.send_channel_data(1, 0x10000, b"\x01")
+    with pytest.raises(ValueError):
+        await cmd.send_channel_data(1, 0xFFFF, b"\x00" * 164)
+    with pytest.raises(ValueError):
+        await cmd.send_channel_data(256, 0xFFFF, b"\x01")
+    with pytest.raises(TypeError):
+        await cmd.send_channel_data(1, 0xFFFF, "text")
+
+    assert sent == []
+
+
 # ---------------------------------------------------------------------------
 # Wire-format parity bundle: AUTOADD_CONFIG (max_hops trailing byte)
 # ---------------------------------------------------------------------------