Please enable JavaScript.

Coggle requires JavaScript to display documents.

AsyncIO in-depth, EventLoop, Entry point: aio.run(main()) Iteration #1…

- - - - # First, coro3 tries to do somethig:
        # do stuff
        
        But then an unhandled Exception occured:
        raise UnexpectedError
        task3 object, that wraps coro3 coroutine, intercepts this error and stores it in its .exception() attribute. It will be dealt with later by caller coroutine – main. Also, task3 sets its .done() flag to indicate that the task is finished and requires no more attention from EventLoop.
        
        EventLoop tasks:
        
        main - awaits for socket
        
        task2 - waits forever
        
        task3 - raised an error
        
        task4 - pending
        
        EventLoop is gaining control...
        
        #
- - - - So, main was passed to run() method and it is added to the task list
        
        EventLoop tasks:
        
        main - just started
        
        While an EventLoop itself controls how coroutines take turns executing their code, main coroutine (which is passed to aio.run()) is considered as a manager that controls how exactly all other coroutines interact.
        
        # First, main does something syncronousely:
        # execute come syncronous code
        
        And then main is creating new task - task1:
        task1 = aio.create_task(coro1)
        It is automatically sheduled for execution at the next iteration of the EventLoop by adding it to the task list
        
        EventLoop tasks:
        
        main - create task1
        
        task1 - just created
        
        1 more item...
        
        aio.current_task() is highligted with bold
- - - - EventLoop switches execution context to task1
        
        EventLoop tasks:
        
        main - awaits task1
        
        task1 - about to be started
        
        task1 executes the wrapee coroutine coro1
        
        All coro1 does is some syncronous computations:
        # do some computations
        
        Meanwhile, main does not continue its execution. It is just waiting, because currently EventLoop is giving computational time to coro1, which blocks current thread with heavy computations. Its important to understand that there is only one thread here and thus no 'true' parallel execution possible. coro1 will hold control until it encounters await expression or returns
        
        Finally, coro1 returns its result:
        return 'coro1_result'
        It is saved to task1.result() (or, if exception would had occured, it is put into .exception() attribute). After that task1 is marked as .done() and exits.
        
        1 more item...
- - - - EventLoop tasks:
        
        main - received result from task1
        
        EventLoop passes result of task1 to the place where it was awaited and main continues execution from the same exact moment that it have been paused at previous EventLoop iteration
        
        Result is stored in result variable and may be used for further processing:
        result = await task1
        
        After that, main is sheduling 3 more tasks:
        task2 = aio.create_task(coro2) task3 = aio.create_task(coro3) task4 = aio.create_task(coro4)
        
        These tasks appear in EventLoop task list and will be run later, when other coroutines will suspend their executiontext
        
        EventLoop tasks:
        
        main - created 3 tasks
        
        task2 - just created
        
        task3 - just created
        
        task4 - just created
        
        1 more item...
        
        If result would have been never awaited, asyncio will track that and raise corresponding RuntimeError
- - - - Let's assume coro2 is performing some operation that have to wait for some external resource for inacceptible amount of time (for example, HTTP query to overloaded server or receiving data from low-speed interface).
        # perform never-ending operation
        
        While coro2 is waiting for data, it passes control back to the Event Loop
        
        #
- - - - # coro4 in turn needs result from coro5. Just like main awaits for the tasks it created, here coro4 awaits for coro5:
        result = await coro5()
        coro5 is not a task, it is just plain coroutine, so execution control is passed directly to it.
        
        'coro5` gains execution control
        
        # coro5 needs to read something from file and thus have to wait for the filesystem read operation to complete:
        # read smth from file
        That, in turn, suspends task4 that is current task at the moment. task4 releases execution control and yields it to the EventLoop.
        
        Returning to the EventLoop...
        
        #
        
        Here and everywhere else I assume, that all operations involving waiting for some external resource are performed with help of asyncio tools, that provide for non-blocking calls (which allow pending coroutines to execute their code while suspended ones are waiting)
- - - - It is seen that every task that is running is waiting for some external resources so that no one can proceed despite of the fact that execution time is available.
        
        This leaves EventLoop no opportunity but to wait until any of these resources would become available. Moreover, the frist task that will become ready to continue execution will be resumed immidiately.
        
        So, at this moment, the application actually blocks.
        
        #
- - - - main waits for task2, so EventLoop gains control again
        
        #
- - - - coro5 does not bother and just returns what it have just read:
        return 'coro5_result'
        
        coro5 is not wrapped into a task. It was called directly from coro4, so it returns its result directly into caller coroutine
        
        coro4 prepends its fancy 50 cent to the result...
        return 'coro4_' + result
        ... and also returns.
        
        coro4 is wrapped into task4, so its result is intercepted by wrapper Task object and stored to its result() attribute.
        
        task4 is marked done() and passes control back to the EventLoop
        
        #
- - - - The first one doubtfully gonna return at all, the second one waits for the first to finish with no luck... That would be a sad story if there were no timeout set on task2
        
        Since timeout exists, eventually time is over and CancelledError is thrown into underlying coro2 coroutine. EventLoop is switching to the task2
        
        coro2 doesn't handle any errors by itself, so task1 sets its canceled() attribute and propagates the error down to main, which becomes an active task
        
        Additionally, task2 is removed from the list
        
        EventLoop tasks:
        
        main - awaits task2
        
        Finally, main intercepts CancelledError and handles it:
        # handle timeout
        
        1 more item...
- - - - :red_cross:

def main():
    # execute come synchronous code
    task1 = aio.create_task(coro1())
    result = await task1
    task2 = aio.create_task(coro2())
    task3 = aio.create_task(coro3())
    task4 = aio.create_task(coro4())
    # read smth from socket
    try:
        await aio.wait_for(task2, timeout=0.5)
    except aio.TimeoutError:
        # handle timeout
    await asyncio.gather(task3, task4, 
        return_exceptions=True)

def coro2():
    # perform never-ending operation
    return 'coro2_result'

def coro4():
    result = await coro5()
    return 'coro4_' + result

def coro3():
    # do stuff
    raise UnexpectedError('error_from_coro3')
    return 'coro3_result'

def coro1():
    # Note: no 'await's inside
    # do some computations
    return 'coro1_result'

def coro5():
    # read smth from file
    return 'coro5_result'

def main():
    # execute come synchronous code
    task1 = aio.create_task(coro1())
    result = await task1
    task2 = aio.create_task(coro2())
    task3 = aio.create_task(coro3())
    task4 = aio.create_task(coro4())
    # read smth from socket
    try:
        await aio.wait_for(task2, timeout=0.5)
    except aio.TimeoutError:
        # handle timeout
    await asyncio.gather(task3, task4, return_exceptions=True)