how to make python awaitable object

Question

In python 3.5.1 one can make use of await/async, however, to use it (as I undestand), you need to have awaitable object. An awaitable object is an object that defines __await__() method returning an iterator. More info here. But I can not google out any example of having this, since most examples have some sort of asyncio.sleep(x) to mimic awaitable object.

My ultimate goal is to make simple websocket serial server, however, I can't pass this first step. This is my (non working code).

import serial
import asyncio

connected = False
port = 'COM9'
#port = '/dev/ttyAMA0'
baud = 57600
timeout=1

class startser(object):

    def __init__(self, port, baud):
        self.port = port
        self.baud = baud       

    def openconn(self):       
        self.ser = serial.Serial(port, baud)

    async def readport(self):
        #gooo= await (self.ser.in_waiting > 0)
        read_byte = async self.ser.read(1).decode('ascii')        
        self.handle_data(read_byte)
        print ("42")  

    def handle_data(self, data):
        print(data)

serr=startser(port,baud)
serr.openconn()

loop = asyncio.get_event_loop()
#loop.run_forever(serr.readport())
loop.run_until_complete(serr.readport())
loop.close()

print ("finitto")

#with serial.Serial('COM9', 115200, timeout=1) as ser:
    #x = ser.read()          # read one byte
    #s = ser.read(10)        # read up to ten bytes (timeout)
    #line = ser.readline()   # read a '\n' terminated line`

Answer 1

I guess there is still no answer because the question is not pretty clear. You correctly said that

An awaitable object is an object that defines __await__() method returning an iterator

Not much to add here. Just return an iterator from that method.

The only thing you need to understand is how does it work. I mean, how asyncio or another similar framework achieves concurrency in a single thread. This is simple on a high level: just get all your code organized as iterators, then call them one-by-one until the values are exhausted.

So, for example, if you have two iterators, let's say first one yields letters and the second one yields numbers, event loop calls first one and gets 'A', then it calls the second one and gets 1 then it calls first one again and gets 'B' and so on and so on, until the iterators are completed. Of course, each of these iterators can do whatever you want before yielding the next value. But, the longer it takes - the longer pause between 'switching tasks' would be. You MUST keep every iteration short:

1. If you have inner loops, use async for - this will allow switching task without explicit yielding.
2. If you have a lot of code which executes for tens or even hundreds of milliseconds, consider rewriting it in smaller pieces. In a case of legacy code, you can use hacks like asyncio.sleep(0) ← this is an allowance for asyncio to switch task here.
3. No blocking operations! This is most important. Consider you do something like socket.recv(). All tasks will be stopped until this call ends. This is why this is called async io in the standard library: you must use theirs implementation of all I/O functions like BaseEventLoop.sock_recv().

I'd recommend you to start (if you didn't yet) with the following docs:

• https://pymotw.com/3/asyncio/
• https://docs.python.org/3/library/asyncio.html
• https://www.python.org/dev/peps/pep-0492