На какой библиотеке построена технология запуска и ожидания передачи данных?

# Библиотеки для асинхронного программирования в Python

Вопрос относится к технологиям асинхронного программирования (async/await). В Python существует несколько ключевых библиотек для запуска и управления асинхронными операциями.

1. asyncio — встроенная библиотека

asyncio — это основная библиотека Python для асинхронного программирования, встроенная в стандартную библиотеку начиная с Python 3.4:

import asyncio

async def fetch_data(url):
    print(f"Fetching {url}")
    await asyncio.sleep(2)  # Имитация сетевого запроса
    return f"Data from {url}"

async def main():
    # Запуск нескольких корутин параллельно
    results = await asyncio.gather(
        fetch_data('http://api1.com'),
        fetch_data('http://api2.com'),
        fetch_data('http://api3.com')
    )
    for result in results:
        print(result)

# Запуск асинхронного кода
asyncio.run(main())

Основные компоненты asyncio:

• Event Loop — основной цикл событий, управляющий выполнением корутин
• Coroutines — функции с async def
• Tasks — обёртки над корутинами
• Futures — объекты, представляющие результат асинхронной операции

2. Популярные async фреймворки

FastAPI (на базе asyncio)

from fastapi import FastAPI
from fastapi.responses import JSONResponse
import asyncio

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    # Асинхронная обработка запроса
    await asyncio.sleep(1)
    return {"item_id": item_id, "name": f"Item {item_id}"}

@app.post("/process")
async def process_data(data: dict):
    # Параллельная обработка
    result1 = asyncio.create_task(long_operation1())
    result2 = asyncio.create_task(long_operation2())
    
    value1, value2 = await asyncio.gather(result1, result2)
    return {"result1": value1, "result2": value2}

async def long_operation1():
    await asyncio.sleep(2)
    return "Operation 1 done"

async def long_operation2():
    await asyncio.sleep(3)
    return "Operation 2 done"

aiohttp — асинхронные HTTP запросы

import aiohttp
import asyncio

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        urls = [
            'http://api.example.com/users',
            'http://api.example.com/posts',
            'http://api.example.com/comments'
        ]
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

results = asyncio.run(main())

3. Другие асинхронные библиотеки

Trio — альтернатива asyncio

import trio

async def fetch_data(url):
    print(f"Fetching {url}")
    await trio.sleep(2)
    return f"Data from {url}"

async def main():
    async with trio.open_nursery() as nursery:
        for url in ['http://1.com', 'http://2.com', 'http://3.com']:
            nursery.start_soon(fetch_data, url)

trio.run(main)

Trio отличается от asyncio:

• Более простой API
• Лучшая обработка ошибок
• Встроенная поддержка отмены операций
• Более предсказуемое поведение

Anyio — абстракция над asyncio и trio

import anyio

async def main():
    async with anyio.open_nursery() as nursery:
        nursery.start_soon(do_something)
        nursery.start_soon(do_something_else)

anyio.run(main)

4. Асинхронные библиотеки для конкретных задач

asyncpg — асинхронный драйвер PostgreSQL

import asyncpg

async def fetch_users():
    conn = await asyncpg.connect(
        user='user',
        password='password',
        database='mydb',
        host='localhost'
    )
    
    # Асинхронный запрос к БД
    users = await conn.fetch('SELECT * FROM users')
    await conn.close()
    return users

motor — асинхронный драйвер MongoDB

from motor.motor_asyncio import AsyncIOMotorClient

async def get_documents():
    client = AsyncIOMotorClient('mongodb://localhost')
    db = client['mydb']
    collection = db['users']
    
    users = await collection.find({}).to_list(None)
    return users

redis-py с asyncio

import redis.asyncio as redis

async def cache_operations():
    r = await redis.from_url('redis://localhost')
    
    await r.set('key', 'value')
    value = await r.get('key')
    
    await r.close()

5. Сравнение подходов

6. Практические примеры

Параллельное выполнение с таймаутом

async def operation_with_timeout():
    try:
        result = await asyncio.wait_for(
            fetch_data('http://api.com'),
            timeout=5.0
        )
    except asyncio.TimeoutError:
        print("Operation timed out")
        return None

asyncio.run(operation_with_timeout())

Обработка исключений в параллельных операциях

async def safe_gather():
    tasks = [
        fetch_url('http://api1.com'),
        fetch_url('http://api2.com'),
        fetch_url('http://api3.com')
    ]
    
    # return_exceptions=True позволяет продолжить, даже если одна операция упадёт
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    for result in results:
        if isinstance(result, Exception):
            print(f"Error: {result}")
        else:
            print(f"Success: {result}")

Итоги

asyncio — это фундаментальная библиотека для асинхронного программирования в Python. На её основе построены FastAPI, aiohttp и множество других инструментов. Выбор между asyncio и Trio зависит от требований проекта, но asyncio остаётся стандартом де-факто в Python экосистеме.