Aiohttp python что это

Результат работы модуля models.py:

1. Подключаемся к БД в докере
2. Дропаем и создаем заново таблицы (чтобы небыло конфликта с существующими записями)
3. Сохраняем данные юзеров и постов в БД

Что здесь делаем: Создаем асинхронный main() и запускаем его в синхронном main(). Внутри async_main() последовательно запускаем асинхронные ф-и:

1. Запуск БД в докере
2. Дроп и создание пустых таблиц
3. Получение данных юзеров и постов с сайта
4. Сохранение юзеров в бд
5. Сохранение постов в бд
6. Закрытие подключения к бд (происходит неявно, автоматически при завершении работы менеджера контекста)

asyncio.gather — метод, который вернет то, что в него было положено, в том же порядке. (deprecated in python 3.10. ) asyncio.run - метод, создающий event loop для асинхронных ф-ий.

Результат работы main.py: В БД, в таблице User появляется 10 пользователей, в таблице Post — 100 записей, связанных отношением many to one к юзерам, написавших их.

P.S. Если будете копировать код - используйте IDE для его запуска т.к. где-то может стоять 4 пробела, а где-то табуляция. Но лучше не копировать, а руками перепечатать, так лучше запомнится и поймется.

AIOHTTP

Aiohttp — асинхронный HTTP-клиент/сервер для модуля asyncio. Это библиотека языка Python, которая нужна для выполнения клиентских запросов и создания веб-сервера с потоковой выдачей и веб-сокетами.

Простым языком, Aiohttp — это технология, которая помогает приложению (сервер) и его пользователям (клиенты) быстрее и обмениваться данными. От того, насколько хорошо реализована эта связь, зависит производительность вашего веб-проекта.

Есть несколько способов реализовать HTTP-клиент для проектов на Python, но Aiohttp — самое популярное решение, быстрое и легко масштабируемое, которое используется практически по умолчанию.

Асинхронность нужна для выполнения нескольких операций, установления соединений, одновременно, без ожидания завершения предыдущих. Использование такого подхода увеличивает скорость работы веб-сервисов в несколько раз, причина низкой производительности которых, обычно, не проведение сложных вычислений, а именно ожидание ввода/вывода.

HTTP-запросы с использованием Aiohttp в Python 3

Одно из критических замечаний, регулярно высказываемых в адрес Python, заключается в том, что в нем нет хорошей реализации параллелизма.

Если вы опытный программист на Python, то наверняка слышали о GIL или Global Interpreter Lock. Эта блокировка защищает доступ к объектам Python таким образом, что только один поток может одновременно выполнять байткод. Она необходима, поскольку Python (в частности, стандартная реализация CPython) не имеет потокобезопасного управления памятью.

Если позволить нескольким потокам работать с одной и той же памятью, могут произойти странные вещи. А подход Python к решению этой проблемы заключается в том, чтобы просто запретить это.

И это еще хуже: GIL приводит к накладным расходам из-за переключения контекста, так что выполнение одного и того же кода в двух разных потоках занимает больше времени, чем выполнение его дважды в одном и том же потоке.

Итак, действительно ли параллелизм в Python невозможен? Вовсе нет! На самом деле, в нашем распоряжении есть несколько инструментов, каждый из которых имеет свои преимущества и недостатки.

Есть многопроцессорная обработка, которая хорошо работает во многих ситуациях, даже несмотря на большие начальные накладные расходы по сравнению с многопоточностью.

Кроме того, хотя я уже упоминал о том, что многопоточность в Python имеет некоторые недостатки по сравнению с другими языками, это не означает, что она бесполезна как способ структурировать выполнение кода. Есть и третий вариант, о котором я расскажу подробнее: асинхронное выполнение.

Пару лет назад среди языков программирования наблюдался некоторый асинхронный бум, и теперь, похоже, каждый основной язык имеет не только возможность асинхронного выполнения с помощью фьючерсов, корутин или обработчиков событий, но и синтаксис async/await. Подробнее об этом позже.

Так что же это такое? На первый взгляд, в Python async работает очень похоже на потоки, с одним существенным отличием — планированием.

Если вы используете потоки в Python, то ядро вашей операционной системы знает об этом и переключается между ними, когда считает нужным. Это называется вытесняющей многозадачностью. Код, выполняющийся в потоке, не знает, что его прерывают, и не может контролировать, когда это произойдет.

При использовании async Python сам выполняет планирование, что позволяет реализовать так называемую кооперативную многозадачность. Код, написанный с использованием этого подхода, должен каким-то образом передать управление интерпретатором, чтобы другой код мог продолжить выполнение. В JavaScript такая передача управления происходит при каждом вызове метода, а в Python вы можете контролировать, когда это происходит.

Зачем нам это нужно? Оказывается, есть класс операций, в которых имеет смысл на некоторое время передать управление: ввод/вывод!

Относительно выполнения логики программы получение чего-либо с жесткого диска занимает много времени, а получение ответа на сетевой запрос — еще больше. Если нам все равно придется ждать, почему бы не сделать за это время что-нибудь полезное?

Это также означает, что выполнение нескольких задач ввода-вывода может происходить практически одновременно. Это дает некоторые преимущества настоящего параллельного выполнения, если только время запуска новой задачи достаточно мало.

В программах, связанных со вводом-выводом, где вы читаете и записываете большое количество файлов, обмениваетесь данными с базами данных или отправляете большое количество сетевых запросов, это может значительно ускорить работу.

Немного истории

Кооперативная многозадачность в Python не является чем-то новым. Люди используют Python для реализации веб-серверов уже довольно давно, и столько же времени ищут способы увеличить количество запросов, которые они могут обрабатывать в минуту. Многие из этих решений основаны на каком-либо событийном цикле с кооперативным планированием.

Twisted, событийно-ориентированный фреймворк сетевого программирования, существует с 2002 года и используется до сих пор. На нем основаны такие проекты, как Scrapy, а Twitch использует его в своем бэкенде.

В настоящее время нет недостатка в библиотеках и фреймворках, реализующих ту или иную форму асинхронного рабочего процесса, причем многие из них специально предназначены для работы с сетями. Вот лишь некоторые из них:

• tornado, веб-сервер/фреймворк
• gevent, сетевая библиотека, основанная на Greenlet
• curio — библиотека для параллельного ввода-вывода, созданная тяжеловесом сообщества Python Dabeaz
• trio — библиотека, призванная сделать асинхронное программирование более доступным

Однако долгое время не хватало интегрированного в язык способа реализации асинхронного ввода-вывода, с функциональностью, упакованной прямо в стандартную библиотеку, и удобными ключевыми словами, позволяющими более прямолинейно и удобно программировать, избегая ада колбэков, который так хорошо знаком программистам, давно работающим на JavaScript.

Осознавая эту необходимость, в PEP 3156 было представлено видение BDFL Гвидо ван Россума по асинхронному вводу/выводу в Python, реализованное в Python 3.3 в виде модуля asyncio.

От редакции Pythonist: вас также может заинтересовать статья «asyncio — параллелизм в Python».

PEP 492, реализованный в Python 3.5, принес нам ключевые слова async/await , и с тех пор появилось множество других дополнений и улучшений, в частности, в версии 3.7.

Сразу оговорюсь, что я не пропагандирую использование asyncio вместо альтернатив, о которых я говорил ранее. У всех них есть свои достоинства и недостатки, но поскольку asyncio является частью стандартной библиотеки Python 3, с него можно начать.

Добро пожаловать в asyncio

Итак, вы убедились в том, что хотите попробовать асинхронность, и решили, что встроенный модуль asyncio — это то, что вам нужно. Какие же возможности вам доступны?

Во-первых, это сам модуль asyncio, который предоставляет несколько необходимых нам примитивов и на котором построены другие библиотеки, упомянутые в этом разделе. Примеры этих примитивов мы рассмотрим в практическом разделе ниже.

Цикл событий (event loop) — это то, что позволяет осуществлять всю кооперативную планировку. На высоком уровне это просто обычный цикл, который отслеживает все и обрабатывает события одно за другим, когда они происходят.

Цикл событий отслеживает задачи, которые помещаются в очередь, откуда их можно разбудить, когда завершится то, чего они ждут (если это вообще возможно). Задачи могут быть проверены на предмет завершения или отменены, если их результат больше не нужен или достигнут тайм-аут.

Задача (Task), в свою очередь, оборачивает корутину (Coroutine). Именно этот код выполняется, когда задача снова активируется. Далее мы на примерах рассмотрим, как это использовать. Пока просто запомните, что цикл событий фактически выполняет только одну задачу за раз и переключается только тогда, когда эта задача передает управление. Поэтому, если у вас есть одна задача, которая продолжает выполняться, то другие, которые все еще находятся в очереди, никогда не завершатся.

Многие библиотеки, которые вы наверняка будете использовать при работе с asyncio, содержатся в группе aio-libs на GitHub. Сюда входят aiohttp, о которой мы подробнее поговорим ниже, а также библиотеки для большого количества других задач, такие как aioftp, aiopg (для PostgreSQL), aioredis, aioelasticsearch, aiokafka, aiodocker, … Есть и другие библиотеки, построенные на их основе, в частности, пара веб-фреймворков, но я предоставлю вам возможность найти их самостоятельно.

Aiohttp — это, безусловно, самый активный проект aio-libs, который, возможно, является основным вариантом использования asyncio.

Aiohttp представляет собой HTTP-клиент и сервер с поддержкой Web-Sockets и таких тонкостей, как промежуточное ПО для обработки запросов и подключаемая маршрутизация.

Вики предоставляет два минимальных примера для начала работы с клиентом или сервером прямо на первой странице, что позволяет быстро опробовать их в работе.

Перейдем к коду

Начнем с самого простого примера:

import asyncio async def a_square(x): print(f'Asynchronously squaring !') return x ** 2 # This will only work in Python 3.7 and above asyncio.run(a_square(2))

Если вы не используете версию Python 3.7 или выше, то вам необходимо заменить вызов run на что-то вроде:

loop = asyncio.get_event_loop() try: loop.run_until_complete(a_square(2)) finally: loop.close()

Довольно просто, не так ли? Функция a_square является корутиной. Ключевое слово async перед определением функции означает, что если вы ее вызовете, на самом деле ничего не произойдет, а произойдет только тогда, когда вы обернете ее в задачу (Task), и цикл событий разбудит ее для выполнения вычислений.

В большинстве случаев нам не нужно делать это явно. Здесь функция run позаботилась обо всем: она запустила цикл, обернула наш корутинный объект и запланировала его как задачу, после чего он немедленно начал выполняться, так как других задач не было.

Рассмотрим кое-что посложнее. Мы можем выстраивать цепочки coroutine, заставляя их ждать друг друга. Например:

import asyncio async def sleeper(x): await asyncio.sleep(x) return x + 1 async def waiter(x): sleepy_result = (await sleepy(x)) ** 2 return sleepy_result # python >= 3.7 asyncio.run(waiter(2))

Здесь корутина waiter должна дождаться завершения работы корутины sleeper .

asyncio.sleep() — это асинхронная версия time.sleep() , поэтому она также является корутинной функцией, как и waiter и sleeper .

Ключевое слово await здесь делает несколько вещей. Во-первых, оно гарантирует, что все, что мы передаем ему, будет обернуто в задачу. Во-вторых, оно назначает эту задачу в очередь активного цикла и, когда задача будет выполнена, возвращает результат.

Это также означает, как вы уже поняли из названия, что код после этой строки начнет выполняться только тогда, когда этот результат будет доступен. Если вы хотите запланировать задачу и продолжить ее выполнение, то это тоже возможно:

import asyncio async def delayed_print(text, time=1): await asyncio.sleep(time) print(text) async def main_coro(): # python >= 3.7 task1 = asyncio.create_task(delayed_print("I'm printed second!", 2)) # python >= 3.3 task2 = asyncio.ensure_future(delayed_print("I'm printed first!")) await asyncio.gather( task1, task2, delayed_print("I'm printed last!", 3) ) # python >= 3.7 asyncio.run(main_coro())

Здесь есть несколько интересных моментов.

Во-первых, мы видим функцию create_task , которая была добавлена в Python 3.7. Она принимает корутину, который оборачивается в Task и планирует выполнение. До версии 3.7 ее эквивалентом была функция ensure_future (которая на самом деле является более низкоуровневой, но выполняет то же самое).

Затем есть функция gather , которая, как следует из названия, собирает результаты всех переданных ей задач и корутин и возвращает их в виде списка.

Теперь, когда мы разобрались с основами, давайте перейдем к тому, ради чего мы, собственно, и собрались: aiohttp! Следующий пример демонстрирует работу клиентской части:

import aiohttp import asyncio async def fetch(session, url): async with session.get(url) as response: return await response.text() async def fetch_all(urls): async with aiohttp.ClientSession() as session: texts = await asyncio.gather(*[ fetch(session, url) for url in urls ]) return texts years_to_fetch = [f'https://en.wikipedia.org/wiki/' for year in range(1990, 2020)] asyncio.run(fetch_all(years_to_fetch))

Этот код представляет собой версию примера на первой странице документации aiohttp с несколькими запросами. Он получает (HTML) текст страниц Википедии за 1990-2019 годы.

Эти GET-запросы запускаются параллельно, поэтому выполнение всех из них занимает примерно столько же времени, сколько выполнение самого длинного.

От редакции Pythonist: также предлагаем почитать «Пособие по HTTP-запросам в Python и Web API».

Конечно, есть ограничения на количество запросов, которые можно выполнить подобным образом. Если вам нужно выполнить тысячи запросов, то, вероятно, следует запускать их частями, но в большинстве случаев это будет работать, как показано на рисунке.

Как и в случае с обычной библиотекой requests, вы можете отправлять не только GET-запросы. Если вам интересны другие методы, вы всегда можете почитать об их использовании в документации.

Библиотека aiohttp также включает в себя серверный компонент, укомплектованный маршрутизатором и всем необходимым для работы с простым веб-сервером или REST API. В следующем примере показаны некоторые вещи, которые можно сделать с его помощью:

from aiohttp import web async def empty(request): return web.Response() async def get_json(request): return web.json_response(< 'path_name_variable': request.match_info.get('name'), 'query_param_a': request.rel_url.query.get('a'), 'query_param_b': request.rel_url.query.get('b'), >) async def redirected(request): location = request.app.router['default'].url_for() raise web.HTTPFound(location=location) async def index(request): return web.FileResponse('./index.html') app = web.Application() app.add_routes([ web.get('/', redirected), web.get('/empty', empty), web.get('/json/', get_json), web.static('/index', index, name='default'), ]) web.run_app(app)

Это последний пример и самый подробный. Он представляет веб-приложение с 4 маршрутами (routes): один маршрут, который перенаправляется на другой, еще один возвращает пустой ответ, третий возвращает статический HTML-файл, а четвертый имеет необязательную переменную пути (path variable) и параметры запроса (query parameters) и возвращает JSON-документ.

Очередь на сверхвысоких скоростях

Одним из интересных моментов в цикле событий asyncio является то, что он подключаемый. Это означает, что вы можете создать свою собственную реализацию. Хотя стандартная реализация, основанная на libev, уже достаточно хороша, есть и другой вариант. Более быстрый вариант!

Эта реализация называется uvloop и основана на libuv — библиотеке асинхронного ввода-вывода, изначально разработанной для node.js, а теперь используемой, в частности, в Julia.

Библиотека uvloop проста в использовании и позволяет ускорить практически все, что вы делаете с помощью asyncio, поэтому было бы стыдно не упомянуть о ней здесь.

От редакции Pythonist: также предлагаем почитать «Асинхронность в Django: бесконечная история».

Обзорный анализ Python веб-фреймворков

Посмотрим, что выгодно отличает фреймворки Python от фреймворков в других языках и разберём, в чём они конкурируют между собой.

Вместе с ML и data scince, web является одним из трёх китов, на которых стоит популярность языка Python. В данном анализе опустим все прелести Python и рассмотрим только веб-инструментарий, то есть фреймворки. Посмотрим, что выгодно отличает их от фреймворков в других языках, и разберём, в чём они конкурируют между собой.

Полезен такой разбор, думаю, будет в первую очередь тем, кто только входит в веб-разработку на Python. А также тем, кто не знает к изучению какой следующей технологии приступить.

Судя по анализу 60 вакансий на позицию Python-разработчика на портале dou.ua, сегодня на рынке востребованы следующие фреймворки (для каждой технологии указано количество связанных вакансий):

Django— 21;Flask— 13;Aiohttp— 5;FastAPI— 4;Falcon— 1;Bottle— 1.

В виде диаграммы представить данную информацию можно так:

Для меня оказалось неожиданным, что Django упомянут в большинстве вакансий. Ещё удивило присутствие Bottle.

Определим критерии для сравнения инструментов:

• документация — насколько читабельна, полна и актуальна документация проекта. Бонусы при оценке получат проекты, имеющие детальные туториалы;
• комьюнити — наличие сообщества единомышленников-разработчиков, работающих с данной технологией и масштабы такого сообщества;
• архитектура — насколько логично и в соответствии с паттернами проектирования построена структура фреймворка;
• функционал — встроенный функционал фреймворка, который покрывает нужды разработчика без подключения сторонних модулей;
• настройка — насколько фреймворк легко настроить и насколько управляем проект, работающий под фреймворком.

Итак, перейдём к самому анализу и начнём, пожалуй, с фаворита рынка — Django.

Django

История этого фреймворка Python начинается в 2003 году, когда разработчики из американской газеты Lawrence Journal-World решили пилить феб-приложения на Python. Уже в 2005 году ребята выкатили в свободное плавание своё детище как веб-фреймворк.

Чем Django так хорош?

Модульность и расширяемость

Во-первых, к модульности принуждает MTV (model-template-view) архитектура фреймворка. С бизнес-логикой приложения, его визуальным оформлением, структурой данных, разработчик работает отдельно.

Хорошая практика в Django — выделять логически обособленный функционал приложения в отдельный application внутри фреймворка. По сути, вы легко компонуете проект из апликейшинов как из конструктора лего.

В Django присутствует каталог на сотни плагинов, которые решают задачи от настройки sitemap до развёртывания полноценной CMS и создания REST API.

Помимо предусмотренных разработчиками фреймворка решений, достаточно просто подключаются аналоги (например Jinja2 вместо стандартного шаблонизатора Django). Хотя заменить, например, ORM достаточно тяжело.

Развитая экосистема

Как я уже упомянул, существуют сотни плагинов для Django, решающих ряд насущных нужд. Помимо сахара в виде таких плагинов фреймворк самодостаточен. «Из коробки» встроены ORM, шаблонизатор, мультиязычность, админ-панель, автоматическая документация и так далее.

Система фреймворка настолько модульна, что параллельно может выполняться разработка бизнес-логики приложения, его API, внешних представлений, наполнение приложения информацией SMM-менеджерами и так далее.

Стабильность

В некой мере этот пункт можно отнести и к экосистеме. Django имеет полную и достаточно качественную документацию. Существуют её переводы — в том числе и на русский язык.

Сообщество разработчиков на Django насчитывает тысячи человек. На любой вопрос разработчик гарантированно найдёт ответ.

Фреймворк используется с 2005 года, и за 16 лет множество багов было устранено, а фич реализовано и улучшено.

Django развивается и поддерживается огромным комьюнити. Django Software Foundation — это некоммерческая организация, которая поддерживает обучение фреймворку, его развитие и распространение.

На Django написаны YouTube, Pinterest, Google. А такие проекты, работающие на Django, подтверждают стабильность экосистемы при работе с большими нагрузками.

Минусы Django:

Для небольших проектов функционал Django избыточен, но в то же время возможности асинхронности в нём весьма ограничены. Поэтому для работы с легкими или асинхронными проектами предпочитают использовать другие фреймворки. Многие встроенные модули достаточно тяжело заменить — админ-панель не всегда легко кастомизировать, а про ORM я уже упоминал. И она, кстати, значительно уступает по гибкости SQLAlchemy.

Итоги:

• документация — 5;
• комьюнити — 5;
• архитектура — 4;
• функционал — 4;
• настройка — 5.

Flask

Flask был создан в 2010 году австрийским программистом Армином Ронахером в качестве первоапрельской шутки. В одном проекте он попробовал собрать свои библиотеки — шаблонизатор Jinja и Werkzeug — инструментарий для WSGI (стандартного интерфейса Python между веб-сервисами). В результате вышел фреймворк Python, о котором мы сейчас и говорим.

За что любят Flask?

Лёгкость

По своей сути Flask — это скелет, на который разработчик может навесить любой удобный для него инструментарий. Причём этот инструментарий не навязывается фреймворком, как в случае с Django. Например, выбирая Flask для проекта, разработчик волен в выборе ORM. Как правило, выбор падает на SQLAlchemy.

Соответственно, Flask выбирают для большего контроля над используемыми компонентами, обретения навыков в настройке и конфигурировании проект. И когда нужен легкий бэк.

По умолчанию Flask предоставляет:

• сервер разработки и отладчик;
• интегрированные инструменты для модульного тестирования;
• возможность отправки REST запросов;
• шаблонизатор Jinja2;
• пакеты-расширения, например flask-login, flask-sqlalchemy, flask-wtf.

Комьюнити

По состоянию на 2016 год, репозиторий с Flask был самым популярным репозиторием Python на GitHub. В него было внесено более 3 тысяч изменений, у него больше 29 тысяч звезд, а за изменениями следят почти 2 тысячи пользователей. Более 250 разработчиков внесли свой вклад.

Благодаря Flask работают Pinterest и LinkedIn.

Поиск ответа на вопросы, связанные с фреймворком, не займёт много времени как и в случае с Django.

Документация

Документация по Flask покрывает практически все возможные вопросы связанные с фреймворком и имеет перевод на русский язык. Она покрывает в том числе разные варианты развёртывания приложения и вопросы подключения сторонних модулей к проекту. Например SQLAlchemy.

Минусы Flask:

Несмотря на все плюсы и простоту фреймворка, он остаётся всего лишь ядром, которое зависит от двух внешних библиотек (Jinja и Werkzeug) и к которому прикрепляются сторонние инструменты.

Flask — песочница для программистов, где можно отточить свои навыки и протестировать решение с помощью нового модуля или библиотеки. Из этого достоинства фреймворка следует и его минус — структура и логика проекта полностью зависят от разработчика, работавшего над проектом.

Итоги:

• документация — 5;
• комьюнити — 5;
• архитектура — 3;
• функционал — 3;
• настройка — 4.

Aiohttp

Aiohttp — это веб-сервер для asyncio. Соответственно имеет весьма ограниченный функционал как самостоятельный инструмент и предназначен для решения узкого круга задач.

В чём особенность инструмента?

Столп на котором базируется Aiohttp — вебсокеты.

Веб-сокетам, в отличие от обычных HTTP-запросов, для ответа не нужны повторяющиеся запросы. Достаточно единожды выполнить запрос и ждать отклика. То есть просто слушать сервер, который будет отправлять вам сообщения по мере готовности.

Веб-сокеты стоит использовать в:

• приложениях реального времени;
• чат-приложениях;
• IoT-приложениях;
• многопользовательских играх.

Минусы

Скудная документация, хоть она и имеет примеры выполнения некоторых задач. Например сокращатель ссылок, клон твиттера, чат, и так далее. Также, разработчику, особенно начинающему, будет достаточно трудно найти ответ на вопрос, который может возникнуть при работе с Aiohttp.

Итоги:

• документация — 3;
• комьюнити — 3;
• архитектура — 3;
• функционал — 3;
• настройка — 4.

FastAPI

FastAPI — фреймворк Python для лёгкого создания API-серверов со встроенными валидацией, сериализацией и асинхронностью. Стоит он на плечах двух других фреймворков. Работой с web в FastAPI занимается Starlette, за валидацию отвечает Pydantic.

Возможности:

• из коробки возможность работы с GraphQL;
• встроенные вебсокеты;
• встроенная аутентификация/автроизация, поддержка JWT, OAuth2;
• автоматическая документация.

Как видим, все возможные плюшки для быстрой разработки быстрого и мощного API прямо в коробке. При этом все возможности хорошо задокументированы, документация описывает буквально всё, включая дебаг и тестирование.

Минусы FastAPI

Пожалуй, достаточно небольшое сообщество и не самые простые настройки для корректно работы приложения. А в тандеме это даёт повышеный порог входа в технологию, с которой новичку будет не так просто разобраться (учтём ещё и асинхронность фреймворка).

Итоги:

• документация — 5;
• комьюнити — 3;
• архитектура — 5;
• функционал — 4;
• настройка — 3.

Falcon и Bottle

Отдельного раздела для каждого из данных двух инструментов, думаю, будет много, так как используют их крайне редко, и решают они достаточно простые задачи.

Falcon как правило, позиционируется как более быстрый аналог легко масштабируемой API вместо стандартного инструментария Фласка.

Bottle, в свою очередь — как минимальный набор базовых инструментов для работы с вебом, включающий в себя работу с шаблонами и обработку форм.