Merge branch 'micropython:master' into master

Author: wemos

micropython/bluetooth/aioble-server/manifest.py

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

micropython/bluetooth/aioble/README.md

@@ -70,7 +70,7 @@ Alternatively, install the `aioble` package, which will install everything.
 Usage
 -----
 
-Passive scan for nearby devices for 5 seconds: (Observer)
+#### Passive scan for nearby devices for 5 seconds: (Observer)
 
 ```py
 async with aioble.scan(duration_ms=5000) as scanner:
@@ -87,7 +87,7 @@ async with aioble.scan(duration_ms=5000, interval_us=30000, window_us=30000, act
         print(result, result.name(), result.rssi, result.services())
 ```
 
-Connect to a peripheral device: (Central)
+#### Connect to a peripheral device: (Central)
 
 ```py
 # Either from scan result
@@ -101,7 +101,7 @@ except asyncio.TimeoutError:
     print('Timeout')
 ```
 
-Register services and wait for connection: (Peripheral, Server)
+#### Register services and wait for connection: (Peripheral, Server)
 
 ```py
 _ENV_SENSE_UUID = bluetooth.UUID(0x181A)
@@ -126,30 +126,95 @@ while True:
     print("Connection from", device)
 ```
 
-Update characteristic value: (Server)
+#### Update characteristic value: (Server)
 
 ```py
+# Write the local value.
 temp_char.write(b'data')
+```
+
+```py
+# Write the local value and notify/indicate subscribers.
+temp_char.write(b'data', send_update=True)
+```
+
+#### Send notifications: (Server)
 
-temp_char.notify(b'optional data')
+```py
+# Notify with the current value.
+temp_char.notify(connection)
+```
 
-await temp_char.indicate(timeout_ms=2000)
+```py
+# Notify with a custom value.
+temp_char.notify(connection, b'optional data')
 ```
 
-Query the value of a characteristic: (Client)
+#### Send indications: (Server)
+
+```py
+# Indicate with current value.
+await temp_char.indicate(connection, timeout_ms=2000)
+```
+
+```py
+# Indicate with custom value.
+await temp_char.indicate(connection, b'optional data', timeout_ms=2000)
+```
+
+This will raise `GattError` if the indication is not acknowledged.
+
+#### Wait for a write from the client: (Server)
+
+```py
+# Normal characteristic, returns the connection that did the write.
+connection = await char.written(timeout_ms=2000)
+```
+
+```py
+# Characteristic with capture enabled, also returns the value.
+char = Characteristic(..., capture=True)
+connection, data = await char.written(timeout_ms=2000)
+```
+
+#### Query the value of a characteristic: (Client)
 
 ```py
 temp_service = await connection.service(_ENV_SENSE_UUID)
 temp_char = await temp_service.characteristic(_ENV_SENSE_TEMP_UUID)
 
 data = await temp_char.read(timeout_ms=1000)
+```
+
+#### Wait for a notification/indication: (Client)
+
+```py
+# Notification
+data = await temp_char.notified(timeout_ms=1000)
+```
 
+```py
+# Indication
+data = await temp_char.indicated(timeout_ms=1000)
+```
+
+#### Subscribe to a characteristic: (Client)
+
+```py
+# Subscribe for notification.
 await temp_char.subscribe(notify=True)
 while True:
     data = await temp_char.notified()
 ```
 
-Open L2CAP channels: (Listener)
+```py
+# Subscribe for indication.
+await temp_char.subscribe(indicate=True)
+while True:
+    data = await temp_char.indicated()
+```
+
+#### Open L2CAP channels: (Listener)
 
 ```py
 channel = await connection.l2cap_accept(_L2CAP_PSN, _L2CAP_MTU)
@@ -158,7 +223,7 @@ n = channel.recvinto(buf)
 channel.send(b'response')
 ```
 
-Open L2CAP channels: (Initiator)
+#### Open L2CAP channels: (Initiator)
 
 ```py
 channel = await connection.l2cap_connect(_L2CAP_PSN, _L2CAP_MTU)

micropython/bluetooth/aioble/aioble/server.py

@@ -257,7 +257,7 @@ def notify(self, connection, data=None):
             raise ValueError("Not supported")
         ble.gatts_notify(connection._conn_handle, self._value_handle, data)
 
-    async def indicate(self, connection, timeout_ms=1000):
+    async def indicate(self, connection, data=None, timeout_ms=1000):
         if not (self.flags & _FLAG_INDICATE):
             raise ValueError("Not supported")
         if self._indicate_connection is not None:
@@ -270,7 +270,7 @@ async def indicate(self, connection, timeout_ms=1000):
 
         try:
             with connection.timeout(timeout_ms):
-                ble.gatts_indicate(connection._conn_handle, self._value_handle)
+                ble.gatts_indicate(connection._conn_handle, self._value_handle, data)
                 await self._indicate_event.wait()
                 if self._indicate_status != 0:
                     raise GattError(self._indicate_status)
@@ -290,8 +290,8 @@ def _indicate_done(conn_handle, value_handle, status):
 
 
 class BufferedCharacteristic(Characteristic):
-    def __init__(self, service, uuid, max_len=20, append=False):
-        super().__init__(service, uuid, read=True)
+    def __init__(self, *args, max_len=20, append=False, **kwargs):
+        super().__init__(*args, **kwargs)
         self._max_len = max_len
         self._append = append
 

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.3.1")
+metadata(version="0.4.1")
 
 # Default installation gives you everything. Install the individual
 # components (or a combination of them) if you want a more minimal install.

micropython/bluetooth/aioble/multitests/ble_buffered_characteristic.py

@@ -0,0 +1,139 @@
+# Test characteristic read/write/notify from both GATTS and GATTC.
+
+import sys
+
+sys.path.append("")
+
+from micropython import const
+import time, machine
+
+import uasyncio as asyncio
+import aioble
+import bluetooth
+
+TIMEOUT_MS = 5000
+
+SERVICE_UUID = bluetooth.UUID("A5A5A5A5-FFFF-9999-1111-5A5A5A5A5A5A")
+CHAR1_UUID = bluetooth.UUID("00000000-1111-2222-3333-444444444444")
+CHAR2_UUID = bluetooth.UUID("00000000-1111-2222-3333-555555555555")
+CHAR3_UUID = bluetooth.UUID("00000000-1111-2222-3333-666666666666")
+
+
+# Acting in peripheral role.
+async def instance0_task():
+    service = aioble.Service(SERVICE_UUID)
+    characteristic1 = aioble.BufferedCharacteristic(service, CHAR1_UUID, write=True)
+    characteristic2 = aioble.BufferedCharacteristic(service, CHAR2_UUID, write=True, max_len=40)
+    characteristic3 = aioble.BufferedCharacteristic(
+        service, CHAR3_UUID, write=True, max_len=80, append=True
+    )
+    aioble.register_services(service)
+
+    multitest.globals(BDADDR=aioble.config("mac"))
+    multitest.next()
+
+    # Wait for central to connect to us.
+    print("advertise")
+    connection = await aioble.advertise(
+        20_000, adv_data=b"\x02\x01\x06\x04\xffMPY", timeout_ms=TIMEOUT_MS
+    )
+    print("connected")
+
+    # The first will just see the second write (truncated).
+    await characteristic1.written(timeout_ms=TIMEOUT_MS)
+    await characteristic1.written(timeout_ms=TIMEOUT_MS)
+    print("written", characteristic1.read())
+
+    # The second will just see the second write (still truncated because MTU
+    # exchange hasn't happened).
+    await characteristic2.written(timeout_ms=TIMEOUT_MS)
+    await characteristic2.written(timeout_ms=TIMEOUT_MS)
+    print("written", characteristic2.read())
+
+    # MTU exchange should happen here.
+
+    # The second will now see the full second write.
+    await characteristic2.written(timeout_ms=TIMEOUT_MS)
+    await characteristic2.written(timeout_ms=TIMEOUT_MS)
+    print("written", characteristic2.read())
+
+    # The third will see the two full writes concatenated.
+    await characteristic3.written(timeout_ms=TIMEOUT_MS)
+    await characteristic3.written(timeout_ms=TIMEOUT_MS)
+    print("written", characteristic3.read())
+
+    # Wait for the central to disconnect.
+    await connection.disconnected(timeout_ms=TIMEOUT_MS)
+    print("disconnected")
+
+
+def instance0():
+    try:
+        asyncio.run(instance0_task())
+    finally:
+        aioble.stop()
+
+
+# Acting in central role.
+async def instance1_task():
+    multitest.next()
+
+    # Connect to peripheral and then disconnect.
+    print("connect")
+    device = aioble.Device(*BDADDR)
+    connection = await device.connect(timeout_ms=TIMEOUT_MS)
+
+    # Discover characteristics.
+    service = await connection.service(SERVICE_UUID)
+    print("service", service.uuid)
+    characteristic1 = await service.characteristic(CHAR1_UUID)
+    print("characteristic1", characteristic1.uuid)
+    characteristic2 = await service.characteristic(CHAR2_UUID)
+    print("characteristic2", characteristic2.uuid)
+    characteristic3 = await service.characteristic(CHAR3_UUID)
+    print("characteristic3", characteristic3.uuid)
+
+    # Write to each characteristic twice, with a long enough value to trigger
+    # truncation.
+    print("write1")
+    await characteristic1.write(
+        "central1-aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", response=True, timeout_ms=TIMEOUT_MS
+    )
+    await characteristic1.write(
+        "central1-bbbbbbbbbbbbbbbbbbbbbbbbbbbbb", response=True, timeout_ms=TIMEOUT_MS
+    )
+    print("write2a")
+    await characteristic2.write(
+        "central2a-aaaaaaaaaaaaaaaaaaaaaaaaaaaa", response=True, timeout_ms=TIMEOUT_MS
+    )
+    await characteristic2.write(
+        "central2a-bbbbbbbbbbbbbbbbbbbbbbbbbbbb", response=True, timeout_ms=TIMEOUT_MS
+    )
+    print("exchange mtu")
+    await connection.exchange_mtu(100)
+    print("write2b")
+    await characteristic2.write(
+        "central2b-aaaaaaaaaaaaaaaaaaaaaaaaaaaa", response=True, timeout_ms=TIMEOUT_MS
+    )
+    await characteristic2.write(
+        "central2b-bbbbbbbbbbbbbbbbbbbbbbbbbbbb", response=True, timeout_ms=TIMEOUT_MS
+    )
+    print("write3")
+    await characteristic3.write(
+        "central3-aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", response=True, timeout_ms=TIMEOUT_MS
+    )
+    await characteristic3.write(
+        "central3-bbbbbbbbbbbbbbbbbbbbbbbbbbbbb", response=True, timeout_ms=TIMEOUT_MS
+    )
+
+    # Disconnect from peripheral.
+    print("disconnect")
+    await connection.disconnect(timeout_ms=TIMEOUT_MS)
+    print("disconnected")
+
+
+def instance1():
+    try:
+        asyncio.run(instance1_task())
+    finally:
+        aioble.stop()

micropython/bluetooth/aioble/multitests/ble_buffered_characteristic.py.exp

@@ -0,0 +1,21 @@
+--- instance0 ---
+advertise
+connected
+written b'central1-bbbbbbbbbbb'
+written b'central2a-bbbbbbbbbb'
+written b'central2b-bbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+written b'central3-aaaaaaaaaaaaaaaaaaaaaaaaaaaaacentral3-bbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+disconnected
+--- instance1 ---
+connect
+service UUID('a5a5a5a5-ffff-9999-1111-5a5a5a5a5a5a')
+characteristic1 UUID('00000000-1111-2222-3333-444444444444')
+characteristic2 UUID('00000000-1111-2222-3333-555555555555')
+characteristic3 UUID('00000000-1111-2222-3333-666666666666')
+write1
+write2a
+exchange mtu
+write2b
+write3
+disconnect
+disconnected

python-ecosys/requests/manifest.py

@@ -1,3 +1,3 @@
-metadata(version="0.8.0", pypi="requests")
+metadata(version="0.8.1", pypi="requests")
 
 package("requests")

python-ecosys/requests/requests/__init__.py

@@ -45,7 +45,7 @@ def request(
     parse_headers=True,
 ):
     redirect = None  # redirection url, None means no redirection
-    chunked_data = data and getattr(data, "__iter__", None) and not getattr(data, "__len__", None)
+    chunked_data = data and getattr(data, "__next__", None) and not getattr(data, "__len__", None)
 
     if auth is not None:
         import ubinascii

python-stdlib/__future__/__future__.py

@@ -5,3 +5,4 @@
 with_statement = True
 print_function = True
 unicode_literals = True
+annotations = True

python-stdlib/__future__/manifest.py

@@ -1,3 +1,3 @@
-metadata(version="0.0.3")
+metadata(version="0.1.0")
 
 module("__future__.py")