Docs and code: Remove all references to uasyncio.

Author: peterhinch

v3/as_demos/aledflash.py

@@ -5,30 +5,35 @@
 # Run on MicroPython board bare hardware
 
 import pyb
-import uasyncio as asyncio
+import asyncio
+
 
 async def toggle(objLED, time_ms):
     while True:
         await asyncio.sleep_ms(time_ms)
         objLED.toggle()
 
+
 # TEST FUNCTION
 
+
 async def main(duration):
     print("Flash LED's for {} seconds".format(duration))
-    leds = [pyb.LED(x) for x in range(1,4)]  # Initialise three on board LED's
+    leds = [pyb.LED(x) for x in range(1, 4)]  # Initialise three on board LED's
     for x, led in enumerate(leds):  # Create a task for each LED
-        t = int((0.2 + x/2) * 1000)
+        t = int((0.2 + x / 2) * 1000)
         asyncio.create_task(toggle(leds[x], t))
     await asyncio.sleep(duration)
 
+
 def test(duration=10):
     try:
         asyncio.run(main(duration))
     except KeyboardInterrupt:
-        print('Interrupted')
+        print("Interrupted")
     finally:
         asyncio.new_event_loop()
-        print('as_demos.aledflash.test() to run again.')
+        print("as_demos.aledflash.test() to run again.")
+
 
 test()

v3/as_demos/apoll.py

@@ -5,22 +5,24 @@
 # Author: Peter Hinch
 # Copyright Peter Hinch 2017 Released under the MIT license
 
-import uasyncio as asyncio
+import asyncio
 import pyb
 import utime as time
 
+
 class Accelerometer(object):
     threshold_squared = 16
+
     def __init__(self, accelhw, timeout):
         self.accelhw = accelhw
         self.timeout = timeout
         self.last_change = time.ticks_ms()
         self.coords = [accelhw.x(), accelhw.y(), accelhw.z()]
 
-    def dsquared(self, xyz):            # Return the square of the distance between this and a passed 
-        return sum(map(lambda p, q : (p-q)**2, self.coords, xyz)) # acceleration vector
+    def dsquared(self, xyz):  # Return the square of the distance between this and a passed
+        return sum(map(lambda p, q: (p - q) ** 2, self.coords, xyz))  # acceleration vector
 
-    def poll(self):                     # Device is noisy. Only update if change exceeds a threshold
+    def poll(self):  # Device is noisy. Only update if change exceeds a threshold
         xyz = [self.accelhw.x(), self.accelhw.y(), self.accelhw.z()]
         if self.dsquared(xyz) > Accelerometer.threshold_squared:
             self.coords = xyz
@@ -31,31 +33,33 @@ def poll(self):                     # Device is noisy. Only update if change exc
     def vector(self):
         return self.coords
 
-    def timed_out(self):                # Time since last change or last timeout report
+    def timed_out(self):  # Time since last change or last timeout report
         if time.ticks_diff(time.ticks_ms(), self.last_change) > self.timeout:
             self.last_change = time.ticks_ms()
             return True
         return False
 
+
 async def accel_coro(timeout=2000):
-    accelhw = pyb.Accel()               # Instantiate accelerometer hardware
-    await asyncio.sleep_ms(30)          # Allow it to settle
+    accelhw = pyb.Accel()  # Instantiate accelerometer hardware
+    await asyncio.sleep_ms(30)  # Allow it to settle
     accel = Accelerometer(accelhw, timeout)
     while True:
         result = accel.poll()
-        if result == 0:                 # Value has changed
+        if result == 0:  # Value has changed
             x, y, z = accel.vector()
             print("Value x:{:3d} y:{:3d} z:{:3d}".format(x, y, z))
-        elif accel.timed_out():         # Report every 2 secs
+        elif accel.timed_out():  # Report every 2 secs
             print("Timeout waiting for accelerometer change")
-        await asyncio.sleep_ms(100)     # Poll every 100ms
+        await asyncio.sleep_ms(100)  # Poll every 100ms
 
 
 async def main(delay):
-    print('Testing accelerometer for {} secs. Move the Pyboard!'.format(delay))
-    print('Test runs for {}s.'.format(delay))
+    print("Testing accelerometer for {} secs. Move the Pyboard!".format(delay))
+    print("Test runs for {}s.".format(delay))
     asyncio.create_task(accel_coro())
     await asyncio.sleep(delay)
-    print('Test complete!')
+    print("Test complete!")
+
 
 asyncio.run(main(20))

v3/as_demos/auart.py

@@ -4,7 +4,7 @@
 # Link X1 and X2 to test.
 
 # We run with no UART timeout: UART read never blocks.
-import uasyncio as asyncio
+import asyncio
 from machine import UART
 
 uart = UART(4, 9600, timeout=0)

v3/as_demos/auart_hd.py

@@ -13,35 +13,36 @@
 # To test link X1-X4 and X2-X3
 
 from pyb import UART
-import uasyncio as asyncio
+import asyncio
 from primitives.delay_ms import Delay_ms
 
 # Dummy device waits for any incoming line and responds with 4 lines at 1 second
 # intervals.
-class Device():
-    def __init__(self, uart_no = 4):
+class Device:
+    def __init__(self, uart_no=4):
         self.uart = UART(uart_no, 9600)
         self.swriter = asyncio.StreamWriter(self.uart, {})
         self.sreader = asyncio.StreamReader(self.uart)
         asyncio.create_task(self._run())
 
     async def _run(self):
-        responses = ['Line 1', 'Line 2', 'Line 3', 'Goodbye']
+        responses = ["Line 1", "Line 2", "Line 3", "Goodbye"]
         while True:
             res = await self.sreader.readline()
             for response in responses:
                 await self.swriter.awrite("{}\r\n".format(response))
                 # Demo the fact that the master tolerates slow response.
                 await asyncio.sleep_ms(300)
 
+
 # The master's send_command() method sends a command and waits for a number of
 # lines from the device. The end of the process is signified by a timeout, when
 # a list of lines is returned. This allows line-by-line processing.
 # A special test mode demonstrates the behaviour with a non-responding device. If
 # None is passed, no commend is sent. The master waits for a response which never
 # arrives and returns an empty list.
-class Master():
-    def __init__(self, uart_no = 2, timeout=4000):
+class Master:
+    def __init__(self, uart_no=2, timeout=4000):
         self.uart = UART(uart_no, 9600)
         self.timeout = timeout
         self.swriter = asyncio.StreamWriter(self.uart, {})
@@ -59,32 +60,34 @@ async def _recv(self):
     async def send_command(self, command):
         self.response = []  # Discard any pending messages
         if command is None:
-            print('Timeout test.')
+            print("Timeout test.")
         else:
             await self.swriter.awrite("{}\r\n".format(command))
-            print('Command sent:', command)
+            print("Command sent:", command)
         self.delay.trigger(self.timeout)  # Re-initialise timer
         while self.delay.running():
             await asyncio.sleep(1)  # Wait for 4s after last msg received
         return self.response
 
+
 async def main():
-    print('This test takes 10s to complete.')
+    print("This test takes 10s to complete.")
     master = Master()
     device = Device()
-    for cmd in ['Run', None]:
+    for cmd in ["Run", None]:
         print()
         res = await master.send_command(cmd)
         # can use b''.join(res) if a single string is required.
         if res:
-            print('Result is:')
+            print("Result is:")
             for line in res:
-                print(line.decode('UTF8'), end='')
+                print(line.decode("UTF8"), end="")
         else:
-            print('Timed out waiting for result.')
+            print("Timed out waiting for result.")
+
 
 def printexp():
-    st = '''Expected output:
+    st = """Expected output:
 This test takes 10s to complete.
 
 Command sent: Run
@@ -96,19 +99,21 @@ def printexp():
 
 Timeout test.
 Timed out waiting for result.
-'''
-    print('\x1b[32m')
+"""
+    print("\x1b[32m")
     print(st)
-    print('\x1b[39m')
+    print("\x1b[39m")
+
 
 def test():
     printexp()
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        print('Interrupted')
+        print("Interrupted")
     finally:
         asyncio.new_event_loop()
-        print('as_demos.auart_hd.test() to run again.')
+        print("as_demos.auart_hd.test() to run again.")
+
 
 test()

v3/as_demos/gather.py

@@ -3,42 +3,47 @@
 # 2. A coro with a timeout
 # 3. A cancellable coro
 
-import uasyncio as asyncio
+import asyncio
+
 
 async def barking(n):
-    print('Start normal coro barking()')
+    print("Start normal coro barking()")
     for _ in range(6):
         await asyncio.sleep(1)
-    print('Done barking.')
+    print("Done barking.")
     return 2 * n
 
+
 async def foo(n):
-    print('Start timeout coro foo()')
+    print("Start timeout coro foo()")
     try:
         while True:
             await asyncio.sleep(1)
             n += 1
     except asyncio.CancelledError:
-        print('Trapped foo timeout.')
+        print("Trapped foo timeout.")
         raise
     return n
 
+
 async def bar(n):
-    print('Start cancellable bar()')
+    print("Start cancellable bar()")
     try:
         while True:
             await asyncio.sleep(1)
             n += 1
     except asyncio.CancelledError:  # Demo of trapping
-        print('Trapped bar cancellation.')
+        print("Trapped bar cancellation.")
         raise
     return n
 
+
 async def do_cancel(task):
     await asyncio.sleep(5)
-    print('About to cancel bar')
+    print("About to cancel bar")
     task.cancel()
 
+
 async def main(rex):
     bar_task = asyncio.create_task(bar(70))  # Note args here
     tasks = []
@@ -48,12 +53,12 @@ async def main(rex):
     try:
         res = await asyncio.gather(*tasks, return_exceptions=rex)
     except asyncio.TimeoutError:
-        print('foo timed out.')
-        res = 'No result'
-    print('Result: ', res)
+        print("foo timed out.")
+        res = "No result"
+    print("Result: ", res)
 
 
-exp_false = '''Test runs for 10s. Expected output:
+exp_false = """Test runs for 10s. Expected output:
 
 Start cancellable bar()
 Start normal coro barking()
@@ -65,8 +70,8 @@ async def main(rex):
 foo timed out.
 Result:  No result
 
-'''
-exp_true = '''Test runs for 10s. Expected output:
+"""
+exp_true = """Test runs for 10s. Expected output:
 
 Start cancellable bar()
 Start normal coro barking()
@@ -77,24 +82,27 @@ async def main(rex):
 Trapped foo timeout.
 Result:  [42, TimeoutError()]
 
-'''
+"""
+
 
 def printexp(st):
-    print('\x1b[32m')
+    print("\x1b[32m")
     print(st)
-    print('\x1b[39m')
+    print("\x1b[39m")
+
 
 def test(rex):
     st = exp_true if rex else exp_false
     printexp(st)
     try:
         asyncio.run(main(rex))
     except KeyboardInterrupt:
-        print('Interrupted')
+        print("Interrupted")
     finally:
         asyncio.new_event_loop()
         print()
-        print('as_demos.gather.test() to run again.')
-        print('as_demos.gather.test(True) to see effect of return_exceptions.')
+        print("as_demos.gather.test() to run again.")
+        print("as_demos.gather.test(True) to see effect of return_exceptions.")
+
 
 test(rex=False)