Please enable JavaScript.

Coggle requires JavaScript to display documents.

Asyncio - Coggle Diagram

- - - - asyncio.run(coro())
        
        considered main entry point to async app
        
        runs coroutine coro in new event loop
        
        defines the lifetime of an event loop
        
        should be called once
        
        may be run in debug mode
      - asyncio.create_task(coro(), name=...)
        
        wraps coro into a Task object, runs it concurently *and may continue execution when coro will await something
      - await coro()
        
        calling coroutine passes its turn to coro and waits for it to return
  - - - pending
      - running
      - cancelled
      - done
- - - - Worker thread:
        eventloop.call_soon_threadsafe(callback, *args)
      - EventLoop thread:
        def callback(): ...
    - - EventLoop thread:
        async def coro(): ...
      - Worker thread:
        future = asyncio.run_coroutine_threadsafe(coro(), eventloop) # blocks until future is resolved or timeout occurs result = future.result(timeout)
  - - - eventloop.call_soon(callback, *args)
        
        Schedule callback to be called with args arguments at the next iteration of the event loop
        
        Order called = order registered
    - - loop.call_later(delay, callback, *args) -> asyncio.TimerHandle
        
        Schedule callback to be called after delay seconds
        
        delay: int / float
        
        Sheduled time is equal => call order is undefined.
      - asyncio.TimerHandle - handle to cancel the sheduled callback
        
        .when() - time when callback will be called
        
        .cancel() - cancel callback execution
        
        .cancelled() - state
    - - eventloop.call_at(timestamp, callback, *args) -> asyncio.TimerHandle
        
        Shedule callback to be called at given time defined by timestamp
        
        Time basis is defined by eventloop.time()
    - - eventloop.run_in_executor(executor, func, *args)
        
        Execute func in separated thread / process pool defined by executor
        with concurrent.futures.ThreadPoolExecutor() as pool: result = await loop.run_in_executor(pool, blocking_io) print('custom thread pool', result)