meshcore 2.3.16__tar.gz → 2.3.19__tar.gz

meshcore-2.3.19/.github/workflows/python-import.yml

@@ -0,0 +1,24 @@
+name: Python package import
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  import:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install package
+        run: python -m pip install .
+      - name: Import installed package
+        run: python -c "import meshcore"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: meshcore
-Version: 2.3.16
+Version: 2.3.19
 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.16 → meshcore-2.3.19}/pyproject.toml

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

{meshcore-2.3.16 → meshcore-2.3.19}/src/meshcore/commands/contact.py

@@ -18,60 +18,39 @@ class ContactCommands(CommandHandlerBase):
         await self.send(data)
 
     async def get_contacts(self, lastmod=0, timeout=5) -> Event:
-        await self.get_contacts_async(lastmod)
-
-        # Inline wait for events to continue waiting for CONTACTS event 
-        # while receiving NEXT_CONTACTs (or it might be missed over serial)
-        try:
-            # Create futures for all expected events
-            futures = []
-            for event_type in [EventType.ERROR, EventType.NEXT_CONTACT, EventType.CONTACTS] :
-                future = asyncio.create_task(
-                    self.dispatcher.wait_for_event(event_type, {}, timeout=timeout)
-                )
-                futures.append(future)
-
-            while True:
+        loop = asyncio.get_running_loop()
+        result = loop.create_future()
+        state = {"activity": False}
+    
+        def on_next(event):
+            state["activity"] = True
+    
+        def on_end(event):
+            if not result.done():
+                result.set_result(event)
     
-                # Wait for the first event to complete or all to timeout
-                done, pending = await asyncio.wait(
-                    futures, timeout=timeout, return_when=asyncio.FIRST_COMPLETED
-                )
+        subs = [
+            self.dispatcher.subscribe(EventType.NEXT_CONTACT, on_next),
+            self.dispatcher.subscribe(EventType.CONTACTS, on_end),
+            self.dispatcher.subscribe(EventType.ERROR, on_end),
+        ]
     
-                # Check if any future completed successfully
-                if len(done) == 0:
+        try:
+            await self.get_contacts_async(lastmod)
+    
+            while True:
+                state["activity"] = False
+                try:
+                    # shield so the timeout doesn't cancel the future itself
+                    return await asyncio.wait_for(asyncio.shield(result), timeout)
+                except asyncio.TimeoutError:
+                    if state["activity"]:
+                        continue  # still receiving contacts, keep waiting
                     logger.debug("Timeout while getting contacts")
-                    for future in pending: # cancel all futures
-                        future.cancel()
                     return Event(EventType.ERROR, {"reason": "timeout waiting for contacts"})
-
-                for future in done:
-                    event = await future
-                    if event is None:
-                        for f in pending:
-                            f.cancel()
-                        return Event(EventType.ERROR, {"reason": "no event received during contacts retrieval"})
-                    if event.type != EventType.NEXT_CONTACT:
-                        for f in pending:
-                            f.cancel()
-                        return event
-
-                futures = []
-
-                for future in pending: # put back pending
-                    futures.append(future)
-
-                future = asyncio.create_task( # and recreate NEXT_CONTACT
-                        self.dispatcher.wait_for_event(EventType.NEXT_CONTACT, {}, timeout)
-                    )
-                futures.append(future)
-    
-        except asyncio.TimeoutError:
-            logger.debug(f"Timeout receiving contacts")
-            return Event(EventType.ERROR, {"reason": "asyncio timeout receiving contacts"})
-        except Exception as e:
-            logger.debug(f"Command error: {e}")
-            return Event(EventType.ERROR, {"error": str(e)})
+        finally:
+            for s in subs:
+                s.unsubscribe()
 
     async def reset_path(self, key: DestinationType) -> Event:
         key_bytes = _validate_destination(key, prefix_length=32)

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

@@ -404,7 +404,7 @@ class MessagingCommands(CommandHandlerBase):
                 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()})")
+        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])
 
@@ -454,30 +454,29 @@ class MessagingCommands(CommandHandlerBase):
         return await self.set_flood_scope(b"", force_unscoped=True)
 
     async def set_default_flood_scope(self, scope):
-        if scope is None:
+
+        if not (scope is None or isinstance(scope, str)):
+            raise TypeError(f"set_flood_scope: unsupported scope type {type(scope).__name__}")
+
+        cmd_data = bytearray([CommandType.SET_DEFAULT_FLOOD_SCOPE.value])
+
+        if scope is None or scope == "0" or scope == "None" or scope == "*" or scope == "": # disable
             logger.debug(f"Resetting default scope")
-            scope_key = b"\0"*16
-            scope_name = ""
-        elif isinstance (scope, str):
-            if scope == "0" or scope == "None" or scope == "*" or scope == "": # disable
-                logger.debug ("Resetting default scope")
-                scope_key = b"\0"*16
-                scope_name = ""
-            else:
-                logger.debug (f"Setting scope to {scope}")
-                if scope[0] != "#":
-                    scope = "#" + scope
-                scope_name = scope
-                scope_key = sha256(scope.encode("utf-8")).digest()[0:16]
+
         else:
-            raise TypeError(f"set_flood_scope: unsupported scope type {type(scope).__name__}")
+            if scope[0] != "#":
+                scope = "#" + scope
+            scope_key = sha256(scope.encode("utf-8")).digest()[0:16]
 
-        logger.debug(f"Setting scope key to {scope_key.hex()}")
+            logger.debug (f"Setting default scope to {scope} key : {scope_key.hex()}")
 
-        cmd_data = bytearray([CommandType.SET_DEFAULT_FLOOD_SCOPE.value])
-        cmd_data.extend(scope_name.encode("utf-8"))
-        cmd_data.extend((31-len(scope))*b'\0')
-        cmd_data.extend(scope_key)
+            name = scope.encode("utf-8")
+            if len(name) >= 31:
+                raise ValueError("Scope name must be shorter than 31 bytes")
+
+            cmd_data.extend(name)
+            cmd_data.extend((31-len(name))*b'\0')
+            cmd_data.extend(scope_key)
 
         return await self.send(cmd_data, [EventType.OK, EventType.ERROR])
 

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

@@ -118,8 +118,8 @@ class MeshCore:
         auto_reconnect: bool = False,
         max_reconnect_attempts: int = 3,
         cx_dly: float = 0.1,
-        rts = False,
-        dtr = True
+        rts = None,
+        dtr = None
     ) -> "MeshCore":
         """Create and connect a MeshCore instance using serial connection"""
         connection = SerialConnection(port, baudrate, cx_dly=cx_dly, rts=rts, dtr=dtr)
@@ -133,10 +133,27 @@ class MeshCore:
             max_reconnect_attempts=max_reconnect_attempts,
         )
         res = await mc.connect()
+        if res is None and dtr is None:
+            logger.info("No response from meshcore node, trying to force DTR = True")
+            dtr = True
+            await mc.disconnect()
+            await asyncio.sleep(1)
+            connection = SerialConnection(port, baudrate, cx_dly=cx_dly, rts=rts, dtr=dtr)
+            mc = cls(
+                connection,
+                debug=debug,
+                only_error=only_error,
+                default_timeout=default_timeout,
+                auto_reconnect=auto_reconnect,
+                max_reconnect_attempts=max_reconnect_attempts,
+            )
+            res = await mc.connect()
         if res is None:
-            logger.info("No response from meshcore node, trying to invert dtr")
+            dtr = not dtr
+            logger.info(f"No response from meshcore node, trying to invert dtr (now {dtr})")
             await mc.disconnect()
-            connection = SerialConnection(port, baudrate, cx_dly=cx_dly, rts=rts, dtr=not dtr)
+            await asyncio.sleep(1)
+            connection = SerialConnection(port, baudrate, cx_dly=cx_dly, rts=rts, dtr=dtr)
             mc = cls(
                 connection,
                 debug=debug,

{meshcore-2.3.16 → meshcore-2.3.19}/src/meshcore/serial_cx.py

@@ -11,7 +11,7 @@ logger = logging.getLogger("meshcore")
 
 
 class SerialConnection:
-    def __init__(self, port, baudrate, cx_dly=0.2, rts=False, dtr=True):
+    def __init__(self, port, baudrate, cx_dly=0.2, rts=None, dtr=None):
         self.port = port
         self.baudrate = baudrate
         self.transport = None
@@ -43,8 +43,10 @@ class SerialConnection:
             self.cx.transport = transport
             logger.debug('port opened')
             if isinstance(transport, serial_asyncio.SerialTransport) and transport.serial:
-                transport.serial.dtr = self.cx.dtr  # DTR should be deasserted on heltec_v2 to avoid serial-open reset/handshake issues
-                transport.serial.rts = self.cx.rts
+                if not self.cx.dtr is None:
+                    transport.serial.dtr = self.cx.dtr  # DTR should be deasserted on heltec_v2 to avoid serial-open reset/handshake issues
+                if not self.cx.rts is None:
+                    transport.serial.rts = self.cx.rts
             self.cx._connected_event.set()
 
         def data_received(self, data):