Merge branch 'micropython:master' into master

Author: wemos

.github/workflows/build_packages.yml

@@ -9,14 +9,16 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v1
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
     - name: Setup environment
       run: source tools/ci.sh && ci_build_packages_setup
     - name: Check manifest files
       run: source tools/ci.sh && ci_build_packages_check_manifest
     - name: Compile package index
       run: source tools/ci.sh && ci_build_packages_compile_index
+    - name: Compile package examples
+      run: source tools/ci.sh && ci_build_packages_examples
     - name: Publish packages for branch
       if: vars.MICROPY_PUBLISH_MIP_INDEX && github.event_name == 'push' && ! github.event.deleted
       run: source tools/ci.sh && ci_push_package_index

.github/workflows/cleanup_published_packages.yml

@@ -7,6 +7,6 @@ jobs:
     runs-on: ubuntu-latest
     if: vars.MICROPY_PUBLISH_MIP_INDEX
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Clean up published files
       run: source tools/ci.sh && ci_cleanup_package_index ${{ github.event.ref }}

.github/workflows/code_formatting.yml

@@ -6,8 +6,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v1
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
     - name: Install packages
       run: source tools/ci.sh && ci_code_formatting_setup
     - name: Run code formatting

.github/workflows/ruff.yml

@@ -0,0 +1,10 @@
+# https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+name: Python code lint with ruff
+on: [push, pull_request]
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: pip install --user ruff
+    - run: ruff --format=github .

.pre-commit-config.yaml

@@ -0,0 +1,11 @@
+repos:
+  - repo: local
+    hooks:
+      - id: codeformat
+        name: MicroPython codeformat.py for changed files
+        entry: tools/codeformat.py -v -f
+        language: python
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.280
+    hooks:
+      - id: ruff

CONTRIBUTING.md

@@ -25,11 +25,21 @@ or packages from micropython-lib, please post at the
 ### Pull requests
 
 The same rules for commit messages, signing-off commits, and commit structure
-apply as for the main MicroPython repository. All Python code is formatted
-using `black`. See [`tools/codeformat.py`](tools/codeformat.py) to apply
-`black` automatically before submitting a PR.
+apply [as for the main MicroPython repository](https://github.com/micropython/micropython/blob/master/CODECONVENTIONS.md).
 
-There are some specific conventions and guidelines for micropython-lib:
+All Python code is formatted using the [black](https://github.com/psf/black)
+tool. You can run [`tools/codeformat.py`](tools/codeformat.py) to apply
+`black` automatically before submitting a PR. The GitHub CI will also run the
+[ruff](https://github.com/astral-sh/ruff) tool to apply further "linting"
+checks.
+
+Similar to the main repository, a configuration is provided for the
+[pre-commit](https://pre-commit.com/) tool to apply `black` code formatting
+rules and run `ruff` automatically. See the documentation for using pre-commit
+in [the code conventions document](https://github.com/micropython/micropython/blob/master/CODECONVENTIONS.md#automatic-pre-commit-hooks)
+
+In addition to the conventions from the main repository, there are some
+specific conventions and guidelines for micropython-lib:
 
 * The first line of the commit message should start with the name of the
   package, followed by a short description of the commit. Package names are

micropython/aioespnow/README.md

@@ -0,0 +1,91 @@
+# `aioespnow`
+
+A supplementary module which extends the micropython `espnow` module to provide
+`asyncio` support.
+
+- Asyncio support is available on all ESP32 targets as well as those ESP8266
+boards which include the `uasyncio` module (ie. ESP8266 devices with at least
+2MB flash storage).
+
+## API reference
+
+- class `AIOESPNow()`: inherits all the methods of the `ESPNow` class and
+  extends the interface with the following async methods:
+
+  - `async AIOESPNow.arecv()`
+
+      Asyncio support for ESPNow.recv(). Note that this method does not take a
+      timeout value as argument.
+
+  - `async AIOESPNow.airecv()`
+
+      Asyncio support for ESPNow.irecv(). Use this method to reduce memory
+      fragmentation, as it will reuse common storage for each new message
+      received, whereas the `arecv()` method will allocate new memory for every
+      message received.
+
+  - `async AIOESPNow.asend(mac, msg, sync=True)`
+  - `async AIOESPNow.asend(msg)`
+
+      Asyncio support for ESPNow.send().
+
+  - `__aiter__()/async __anext__()`
+
+      AIOESPNow also supports reading incoming messages by asynchronous
+      iteration using `async for`, eg:
+
+    ```python
+      e = AIOESPNow()
+      e.active(True)
+      async def recv_till_halt(e):
+          async for mac, msg in e:
+              print(mac, msg)
+              if msg == b'halt':
+                  break
+      asyncio.run(recv_till_halt(e))
+    ```
+
+## Example Usage
+
+A small async server example::
+
+```python
+    import network
+    import aioespnow
+    import uasyncio as asyncio
+
+    # A WLAN interface must be active to send()/recv()
+    network.WLAN(network.STA_IF).active(True)
+
+    e = aioespnow.AIOESPNow()  # Returns AIOESPNow enhanced with async support
+    e.active(True)
+    peer = b'\xbb\xbb\xbb\xbb\xbb\xbb'
+    e.add_peer(peer)
+
+    # Send a periodic ping to a peer
+    async def heartbeat(e, peer, period=30):
+        while True:
+            if not await e.asend(peer, b'ping'):
+                print("Heartbeat: peer not responding:", peer)
+            else:
+                print("Heartbeat: ping", peer)
+            await asyncio.sleep(period)
+
+    # Echo any received messages back to the sender
+    async def echo_server(e):
+        async for mac, msg in e:
+            print("Echo:", msg)
+            try:
+                await e.asend(mac, msg)
+            except OSError as err:
+                if len(err.args) > 1 and err.args[1] == 'ESP_ERR_ESPNOW_NOT_FOUND':
+                    e.add_peer(mac)
+                    await e.asend(mac, msg)
+
+    async def main(e, peer, timeout, period):
+        asyncio.create_task(heartbeat(e, peer, period))
+        asyncio.create_task(echo_server(e))
+        await asyncio.sleep(timeout)
+
+    asyncio.run(main(e, peer, 120, 10))
+```

micropython/aioespnow/aioespnow.py

@@ -0,0 +1,31 @@
+# aioespnow module for MicroPython on ESP32 and ESP8266
+# MIT license; Copyright (c) 2022 Glenn Moloney @glenn20
+
+import uasyncio as asyncio
+import espnow
+
+
+# Modelled on the uasyncio.Stream class (extmod/stream/stream.py)
+# NOTE: Relies on internal implementation of uasyncio.core (_io_queue)
+class AIOESPNow(espnow.ESPNow):
+    # Read one ESPNow message
+    async def arecv(self):
+        yield asyncio.core._io_queue.queue_read(self)
+        return self.recv(0)  # type: ignore[misc]
+
+    async def airecv(self):
+        yield asyncio.core._io_queue.queue_read(self)
+        return self.irecv(0)  # type: ignore[misc]
+
+    async def asend(self, mac, msg=None, sync=None):
+        if msg is None:
+            msg, mac = mac, None  # If msg is None: swap mac and msg
+        yield asyncio.core._io_queue.queue_write(self)
+        return self.send(mac, msg, sync)  # type: ignore[misc]
+
+    # "async for" support
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        return await self.airecv()

micropython/aioespnow/manifest.py

@@ -0,0 +1,6 @@
+metadata(
+    description="Extends the micropython espnow module with methods to support asyncio.",
+    version="0.1.0",
+)
+
+module("aioespnow.py")

micropython/aiorepl/README.md

@@ -50,11 +50,17 @@ async def main():
 asyncio.run(main())
 ```
 
-The optional globals passed to `task([globals])` allows you to specify what
-will be in scope for the REPL. By default it uses `__main__`, which is the
-same scope as the regular REPL (and `main.py`). In the example above, the
-REPL will be able to call the `demo()` function as well as get/set the
-`state` variable.
+An optional globals dictionary can be passed to `aiorepl.task()`, which allows
+you to specify what will be in scope for the REPL. By default it uses the
+globals dictionary from the `__main__` module, which is the same scope as the
+regular REPL (and `main.py`). In the example above, the REPL will be able to
+call the `demo()` function as well as get/set the `state` variable.
+
+You can also provide your own dictionary, e.g. `aiorepl.task({"obj": obj })`,
+or use the globals dict from the current module, e.g.
+`aiorepl.task(globals())`. Note that you cannot use a class instance's members
+dictionary, e.g. `aiorepl.task(obj.__dict__)`, as this is read-only in
+MicroPython.
 
 Instead of the regular `>>> ` prompt, the asyncio REPL will show `--> `.
 

micropython/aiorepl/aiorepl.py

@@ -1,6 +1,7 @@
 # MIT license; Copyright (c) 2022 Jim Mussared
 
 import micropython
+from micropython import const
 import re
 import sys
 import time
@@ -26,19 +27,21 @@ async def execute(code, g, s):
         if "await " in code:
             # Execute the code snippet in an async context.
             if m := _RE_IMPORT.match(code) or _RE_FROM_IMPORT.match(code):
-                code = f"global {m.group(3) or m.group(1)}\n    {code}"
+                code = "global {}\n    {}".format(m.group(3) or m.group(1), code)
             elif m := _RE_GLOBAL.match(code):
-                code = f"global {m.group(1)}\n    {code}"
+                code = "global {}\n    {}".format(m.group(1), code)
             elif not _RE_ASSIGN.search(code):
-                code = f"return {code}"
+                code = "return {}".format(code)
 
-            code = f"""
+            code = """
 import uasyncio as asyncio
 async def __code():
-    {code}
+    {}
 
 __exec_task = asyncio.create_task(__code())
-"""
+""".format(
+                code
+            )
 
             async def kbd_intr_task(exec_task, s):
                 while True:
@@ -81,7 +84,7 @@ async def kbd_intr_task(exec_task, s):
                 micropython.kbd_intr(-1)
 
     except Exception as err:
-        print(f"{type(err).__name__}: {err}")
+        print("{}: {}".format(type(err).__name__, err))
 
 
 # REPL task. Invoke this with an optional mutable globals dict.

micropython/aiorepl/manifest.py

@@ -1,5 +1,5 @@
 metadata(
-    version="0.1",
+    version="0.1.1",
     description="Provides an asynchronous REPL that can run concurrently with an asyncio, also allowing await expressions.",
 )
 

micropython/bluetooth/aioble-client/manifest.py

@@ -1,4 +1,4 @@
-metadata(version="0.2.0")
+metadata(version="0.3.0")
 
 require("aioble-core")
 

micropython/bluetooth/aioble-server/manifest.py

@@ -1,4 +1,4 @@
-metadata(version="0.2.0")
+metadata(version="0.3.0")
 
 require("aioble-core")
 

micropython/bluetooth/aioble/aioble/client.py

@@ -439,7 +439,7 @@ class ClientDescriptor(BaseClientCharacteristic):
     def __init__(self, characteristic, dsc_handle, uuid):
         self.characteristic = characteristic
 
-        super().__init__(dsc_handle, _FLAG_READ | _FLAG_WRITE_NO_RESPONSE, uuid)
+        super().__init__(dsc_handle, _FLAG_READ | _FLAG_WRITE, uuid)
 
     def __str__(self):
         return "Descriptor: {} {} {}".format(self._value_handle, self.properties, self.uuid)

micropython/bluetooth/aioble/aioble/server.py

@@ -38,9 +38,6 @@
 
 _FLAG_WRITE_CAPTURE = const(0x10000)
 
-_FLAG_DESC_READ = const(1)
-_FLAG_DESC_WRITE = const(2)
-
 
 _WRITE_CAPTURE_QUEUE_LIMIT = const(10)
 
@@ -307,14 +304,13 @@ class Descriptor(BaseCharacteristic):
     def __init__(self, characteristic, uuid, read=False, write=False, initial=None):
         characteristic.descriptors.append(self)
 
-        # Workaround for https://github.com/micropython/micropython/issues/6864
         flags = 0
         if read:
-            flags |= _FLAG_DESC_READ
+            flags |= _FLAG_READ
         if write:
+            flags |= _FLAG_WRITE
             self._write_event = asyncio.ThreadSafeFlag()
             self._write_data = None
-            flags |= _FLAG_DESC_WRITE
 
         self.uuid = uuid
         self.flags = flags

micropython/bluetooth/aioble/examples/l2cap_file_client.py

@@ -87,7 +87,7 @@ async def download(self, path, dest):
 
         send_seq = await self._command(_COMMAND_SEND, path.encode())
 
-        with open(dest, "wb") as f:
+        with open(dest, "wb") as f:  # noqa: ASYNC101
             total = 0
             buf = bytearray(self._channel.our_mtu)
             mv = memoryview(buf)

micropython/bluetooth/aioble/examples/l2cap_file_server.py

@@ -82,7 +82,7 @@ async def l2cap_task(connection):
 
             if send_file:
                 print("Sending:", send_file)
-                with open(send_file, "rb") as f:
+                with open(send_file, "rb") as f:  # noqa: ASYNC101
                     buf = bytearray(channel.peer_mtu)
                     mv = memoryview(buf)
                     while n := f.readinto(buf):

micropython/bluetooth/aioble/manifest.py

@@ -3,7 +3,7 @@
 # code. This allows (for development purposes) all the files to live in the
 # one directory.
 
-metadata(version="0.2.1")
+metadata(version="0.3.1")
 
 # Default installation gives you everything. Install the individual
 # components (or a combination of them) if you want a more minimal install.

micropython/bundles/bundle-networking/manifest.py

@@ -5,5 +5,9 @@
 
 require("mip")
 require("ntptime")
-require("urequests")
+require("requests")
 require("webrepl")
+
+# Provide urequests (which just forwards to requests) for backwards
+# compatibility.
+require("urequests")

micropython/drivers/bus/onewire/manifest.py

@@ -1 +1,3 @@
+metadata(description="Onewire driver.", version="0.1.0")
+
 module("onewire.py", opt=3)

micropython/drivers/codec/wm8960/manifest.py

@@ -1 +1,3 @@
+metadata(description="WM8960 codec.", version="0.1.1")
+
 module("wm8960.py", opt=3)