# Тестовый файл LLM { #llm-test-file }
-Этот документ проверяет, понимает ли <abbr title="Large Language Model – Большая языковая модель">LLM</abbr>, переводящая документацию, `general_prompt` в `scripts/translate.py` и языковой специфичный промпт в `docs/{language code}/llm-prompt.md`. Языковой специфичный промпт добавляется к `general_prompt`.
+Этот документ проверяет, понимает ли <abbr title="Large Language Model - Большая языковая модель">LLM</abbr>, переводящая документацию, `general_prompt` в `scripts/translate.py` и языковой специфичный промпт в `docs/{language code}/llm-prompt.md`. Языковой специфичный промпт добавляется к `general_prompt`.
-Тесты, добавленные здесь, увидят все создатели языковых промптов.
+Тесты, добавленные здесь, увидят все создатели языковых специфичных промптов.
Использование:
* Проверьте, всё ли в порядке в переводе.
* При необходимости улучшите ваш языковой специфичный промпт, общий промпт или английский документ.
* Затем вручную исправьте оставшиеся проблемы в переводе, чтобы он был хорошим.
-* Ð
\9fеÑ
\80еведиÑ
\82е заново, имеÑ
\8f Ñ
\85оÑ
\80оÑ
\88ий пеÑ
\80евод на меÑ
\81Ñ
\82е. Ð
\98деалÑ
\8cнÑ
\8bм Ñ
\80езÑ
\83лÑ
\8cÑ
\82аÑ
\82ом бÑ
\83деÑ
\82 Ñ
\81иÑ
\82Ñ
\83аÑ
\86иÑ
\8f, когда LLM болÑ
\8cÑ
\88е не вноÑ
\81иÑ
\82 изменений в пеÑ
\80евод. ÐÑ
\82о ознаÑ
\87аеÑ
\82, Ñ
\87Ñ
\82о обÑ
\89ий пÑ
\80омпÑ
\82 и ваÑ
\88 Ñ
\8fзÑ
\8bковой Ñ
\81пеÑ
\86иÑ
\84иÑ
\87нÑ
\8bй пÑ
\80омпÑ
\82 Ð
¼Ð°ÐºÑ\81ималÑ\8cно Ñ\85оÑ\80оÑ\88и (иногда он будет делать несколько, казалось бы, случайных изменений, причина в том, что <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">LLM — недетерминированные алгоритмы</a>).
+* Ð
\9fеÑ
\80еведиÑ
\82е заново, имеÑ
\8f Ñ
\85оÑ
\80оÑ
\88ий пеÑ
\80евод на меÑ
\81Ñ
\82е. Ð
\98деалÑ
\8cнÑ
\8bм Ñ
\80езÑ
\83лÑ
\8cÑ
\82аÑ
\82ом бÑ
\83деÑ
\82 Ñ
\81иÑ
\82Ñ
\83аÑ
\86иÑ
\8f, когда LLM болÑ
\8cÑ
\88е не вноÑ
\81иÑ
\82 изменений в пеÑ
\80евод. ÐÑ
\82о ознаÑ
\87аеÑ
\82, Ñ
\87Ñ
\82о обÑ
\89ий пÑ
\80омпÑ
\82 и ваÑ
\88 Ñ
\8fзÑ
\8bковой Ñ
\81пеÑ
\86иÑ
\84иÑ
\87нÑ
\8bй пÑ
\80омпÑ
\82 Ð
½Ð°Ñ\81Ñ\82олÑ\8cко Ñ\85оÑ\80оÑ\88и, наÑ\81колÑ\8cко Ñ\8dÑ\82о возможно (иногда он будет делать несколько, казалось бы, случайных изменений, причина в том, что <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">LLM — недетерминированные алгоритмы</a>).
Тесты:
### abbr даёт полную расшифровку { #the-abbr-gives-a-full-phrase }
-* <abbr title="Getting Things Done – Как привести дела в порядок">GTD</abbr>
-* <abbr title="less than – меньше чем"><code>lt</code></abbr>
-* <abbr title="XML Web Token – XML веб‑токен">XWT</abbr>
-* <abbr title="Parallel Server Gateway Interface – Параллельный серверный интерфейс шлюза">PSGI</abbr>
+* <abbr title="Getting Things Done - Как привести дела в порядок">GTD</abbr>
+* <abbr title="less than - меньше чем"><code>lt</code></abbr>
+* <abbr title="XML Web Token - XML веб‑токен">XWT</abbr>
+* <abbr title="Parallel Server Gateway Interface - Параллельный серверный интерфейс шлюза">PSGI</abbr>
### abbr даёт объяснение { #the-abbr-gives-an-explanation }
### abbr даёт полную расшифровку и объяснение { #the-abbr-gives-a-full-phrase-and-an-explanation }
-* <abbr title="Mozilla Developer Network – Сеть разработчиков Mozilla: документация для разработчиков, созданная командой Firefox">MDN</abbr>
-* <abbr title="Input/Output – Ввод/Вывод: чтение или запись на диск, сетевое взаимодействие.">I/O</abbr>.
+* <abbr title="Mozilla Developer Network - Сеть разработчиков Mozilla: документация для разработчиков, созданная командой Firefox">MDN</abbr>
+* <abbr title="Input/Output - Ввод/Вывод: чтение или запись на диск, сетевое взаимодействие.">I/O</abbr>.
////
{* ../../docs_src/path_operation_advanced_configuration/tutorial001_py39.py hl[6] *}
-### Использование имени функции-обработчика пути как operationId { #using-the-path-operation-function-name-as-the-operationid }
+### Использование имени *функции-обработчика пути* как operationId { #using-the-path-operation-function-name-as-the-operationid }
Если вы хотите использовать имена функций ваших API в качестве `operationId`, вы можете пройти по всем из них и переопределить `operation_id` каждой *операции пути* с помощью их `APIRoute.name`.
## Исключить из OpenAPI { #exclude-from-openapi }
-ЧÑ\82обÑ\8b иÑ\81клÑ\8eÑ\87иÑ\82Ñ\8c *опеÑ\80аÑ\86иÑ\8e пÑ\83Ñ\82и* из генеÑ\80иÑ\80Ñ\83емой Ñ\81Ñ\85емÑ\8b OpenAPI (а знаÑ\87иÑ\82, и из авÑ\82омаÑ\82иÑ\87еÑ\81кой документации), используйте параметр `include_in_schema` и установите его в `False`:
+ЧÑ\82обÑ\8b иÑ\81клÑ\8eÑ\87иÑ\82Ñ\8c *опеÑ\80аÑ\86иÑ\8e пÑ\83Ñ\82и* из генеÑ\80иÑ\80Ñ\83емой Ñ\81Ñ\85емÑ\8b OpenAPI (а знаÑ\87иÑ\82, и из авÑ\82омаÑ\82иÑ\87еÑ\81киÑ\85 Ñ\81иÑ\81Ñ\82ем документации), используйте параметр `include_in_schema` и установите его в `False`:
{* ../../docs_src/path_operation_advanced_configuration/tutorial003_py39.py hl[6] *}
Добавление `\f` (экранированного символа «form feed») заставит **FastAPI** обрезать текст, используемый для OpenAPI, в этой точке.
-ÐÑ\82а Ñ\87аÑ\81Ñ\82Ñ\8c не попадÑ\91Ñ\82 в докÑ\83менÑ\82аÑ\86иÑ\8e, но другие инструменты (например, Sphinx) смогут использовать остальное.
+ÐÑ\82о не оÑ\82обÑ\80азиÑ\82Ñ\81Ñ\8f в докÑ\83менÑ\82аÑ\86ии, но другие инструменты (например, Sphinx) смогут использовать остальное.
{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
Вы, вероятно, уже видели, как объявлять `response_model` и `status_code` для *операции пути*.
-Это определяет метаданные об основном ответе *операции пути*.
+Это определяет метаданные об основном HTTP-ответе *операции пути*.
Также можно объявлять дополнительные ответы с их моделями, статус-кодами и т.д.
Там есть `tags`, `parameters`, `requestBody`, `responses` и т.д.
-Эта спецификация OpenAPI, специфичная для *операции пути*, обычно генерируется автоматически **FastAPI**, но вы также можете её расширить.
+Эта специфичная для *операции пути* схема OpenAPI обычно генерируется автоматически **FastAPI**, но вы также можете её расширить.
/// tip | Совет
}
```
-### Пользовательская схема OpenAPI для операции пути { #custom-openapi-path-operation-schema }
+### Пользовательская схема OpenAPI для *операции пути* { #custom-openapi-path-operation-schema }
-Словарь в `openapi_extra` будет объединён с автоматически сгенерированной схемой OpenAPI для *операции пути*.
+СловаÑ\80Ñ\8c в `openapi_extra` бÑ\83деÑ\82 глÑ\83боко обÑ\8aединÑ\91н Ñ\81 авÑ\82омаÑ\82иÑ\87еÑ\81ки Ñ\81генеÑ\80иÑ\80ованной Ñ\81Ñ\85емой OpenAPI длÑ\8f *опеÑ\80аÑ\86ии пÑ\83Ñ\82и*.
Таким образом, вы можете добавить дополнительные данные к автоматически сгенерированной схеме.
-Например, вы можете решить читать и валидировать запрос своим кодом, не используя автоматические возможности FastAPI и Pydantic, но при этом захотите описать запрос в схеме OpenAPI.
+Например, вы можете решить читать и валидировать HTTP-запрос своим кодом, не используя автоматические возможности FastAPI и Pydantic, но при этом захотите описать HTTP-запрос в схеме OpenAPI.
Это можно сделать с помощью `openapi_extra`:
Используя тот же приём, вы можете воспользоваться Pydantic-моделью, чтобы определить JSON Schema, которая затем будет включена в пользовательский раздел схемы OpenAPI для *операции пути*.
-И вы можете сделать это, даже если тип данных в запросе — не JSON.
+И вы можете сделать это, даже если тип данных в HTTP-запросе — не JSON.
-Например, в этом приложении мы не используем встроенную функциональность FastAPI для извлечения JSON Schema из моделей Pydantic, равно как и автоматическую валидацию JSON. Мы объявляем тип содержимого запроса как YAML, а не JSON:
-
-//// tab | Pydantic v2
+Например, в этом приложении мы не используем встроенную функциональность FastAPI для извлечения JSON Schema из моделей Pydantic, равно как и автоматическую валидацию JSON. Мы объявляем тип содержимого HTTP-запроса как YAML, а не JSON:
{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
-
-////
-
-/// info | Информация
-
-В Pydantic версии 1 метод для получения JSON Schema модели назывался `Item.schema()`, в Pydantic версии 2 метод называется `Item.model_json_schema()`.
-
-///
-
Тем не менее, хотя мы не используем встроенную функциональность по умолчанию, мы всё равно используем Pydantic-модель, чтобы вручную сгенерировать JSON Schema для данных, которые мы хотим получить в YAML.
-Затем мы работаем с запросом напрямую и извлекаем тело как `bytes`. Это означает, что FastAPI даже не попытается распарсить полезную нагрузку запроса как JSON.
+Затем мы работаем с HTTP-запросом напрямую и извлекаем тело как `bytes`. Это означает, что FastAPI даже не попытается распарсить полезную нагрузку HTTP-запроса как JSON.
-А затем в нашем коде мы напрямую парсим этот YAML и снова используем ту же Pydantic-модель для валидации YAML-содержимого:
-
-//// tab | Pydantic v2
+А затем в нашем коде мы напрямую парсим это содержимое YAML и снова используем ту же Pydantic-модель, чтобы валидировать YAML-содержимое:
{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
-
-////
-
-/// info | Информация
-
-В Pydantic версии 1 метод для парсинга и валидации объекта назывался `Item.parse_obj()`, в Pydantic версии 2 метод называется `Item.model_validate()`.
-
-///
-
/// tip | Совет
Здесь мы переиспользуем ту же Pydantic-модель.
</div>
-/// info | Информация
-
-В Pydantic v1 он входил в основной пакет. Теперь он распространяется как отдельный пакет, чтобы вы могли установить его только при необходимости.
-
-///
-
### Создание объекта `Settings` { #create-the-settings-object }
Импортируйте `BaseSettings` из Pydantic и создайте подкласс, очень похожий на Pydantic‑модель.
Вы можете использовать все те же возможности валидации и инструменты, что и для Pydantic‑моделей, например разные типы данных и дополнительную валидацию через `Field()`.
-//// tab | Pydantic v2
-
{* ../../docs_src/settings/tutorial001_py39.py hl[2,5:8,11] *}
-////
-
-//// tab | Pydantic v1
-
-/// info | Информация
-
-В Pydantic v1 вы бы импортировали `BaseSettings` напрямую из `pydantic`, а не из `pydantic_settings`.
-
-///
-
-{* ../../docs_src/settings/tutorial001_pv1_py39.py hl[2,5:8,11] *}
-
-////
-
/// tip | Совет
Если вам нужно что-то быстро скопировать и вставить, не используйте этот пример — воспользуйтесь последним ниже.
Затем обновите ваш `config.py` так:
-//// tab | Pydantic v2
-
{* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
/// tip | Совет
///
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
-
-/// tip | Совет
-
-Класс `Config` используется только для конфигурации Pydantic. Подробнее см. <a href="https://docs.pydantic.dev/1.10/usage/model_config/" class="external-link" target="_blank">Pydantic Model Config</a>.
-
-///
-
-////
-
-/// info | Информация
-
-В Pydantic версии 1 конфигурация задавалась во внутреннем классе `Config`, в Pydantic версии 2 — в атрибуте `model_config`. Этот атрибут принимает `dict`, и чтобы получить автозавершение и ошибки «на лету», вы можете импортировать и использовать `SettingsConfigDict` для описания этого `dict`.
-
-///
-
Здесь мы задаем параметр конфигурации `env_file` внутри вашего класса Pydantic `Settings` и устанавливаем значение равным имени файла dotenv, который хотим использовать.
### Создание `Settings` только один раз с помощью `lru_cache` { #creating-the-settings-only-once-with-lru-cache }
Если у вас старое приложение FastAPI, возможно, вы используете Pydantic версии 1.
-FastAPI поддеÑ\80живаеÑ\82 и Pydantic v1, и v2 наÑ\87инаÑ\8f Ñ\81 веÑ\80Ñ\81ии 0.100.0.
+FastAPI веÑ\80Ñ\81ии 0.100.0 поддеÑ\80живал либо Pydantic v1, либо v2. Ð\9eн иÑ\81полÑ\8cзовал Ñ\82Ñ\83 веÑ\80Ñ\81иÑ\8e, коÑ\82оÑ\80аÑ\8f бÑ\8bла Ñ\83Ñ\81Ñ\82ановлена.
-Если у вас был установлен Pydantic v2, использовался он. Если вместо этого был установлен Pydantic v1 — использовался он.
+FastAPI версии 0.119.0 добавил частичную поддержку Pydantic v1 изнутри Pydantic v2 (как `pydantic.v1`), чтобы упростить миграцию на v2.
-Сейчас Pydantic v1 объявлен устаревшим, и поддержка его будет удалена в следующих версиях FastAPI, поэтому вам следует **перейти на Pydantic v2**. Так вы получите последние возможности, улучшения и исправления.
+FastAPI 0.126.0 убрал поддержку Pydantic v1, при этом ещё некоторое время продолжал поддерживать `pydantic.v1`.
/// warning | Предупреждение
-Кроме того, команда Pydantic прекратила поддержку Pydantic v1 для последних версий Python, начиная с **Python 3.14**.
+Команда Pydantic прекратила поддержку Pydantic v1 для последних версий Python, начиная с **Python 3.14**.
+
+Это включает `pydantic.v1`, который больше не поддерживается в Python 3.14 и выше.
Если вы хотите использовать последние возможности Python, вам нужно убедиться, что вы используете Pydantic v2.
///
-Ð\95Ñ\81ли Ñ\83 ваÑ\81 Ñ\81Ñ\82аÑ\80ое пÑ\80иложение FastAPI Ñ\81 Pydantic v1, здеÑ\81Ñ\8c Ñ\8f покажÑ\83, как мигÑ\80иÑ\80оваÑ\82Ñ\8c на Pydantic v2, и **новÑ\8bе возможноÑ\81Ñ\82и в FastAPI 0.119.0**, которые помогут выполнить постепенную миграцию.
+Ð\95Ñ\81ли Ñ\83 ваÑ\81 Ñ\81Ñ\82аÑ\80ое пÑ\80иложение FastAPI Ñ\81 Pydantic v1, здеÑ\81Ñ\8c Ñ\8f покажÑ\83, как мигÑ\80иÑ\80оваÑ\82Ñ\8c на Pydantic v2, и **возможноÑ\81Ñ\82и FastAPI 0.119.0**, которые помогут выполнить постепенную миграцию.
## Официальное руководство { #official-guide }
Вы можете использовать <a href="https://github.com/pydantic/bump-pydantic" class="external-link" target="_blank">`bump-pydantic`</a> от той же команды Pydantic.
-ÐÑ\82оÑ\82 инÑ\81Ñ\82Ñ\80Ñ\83менÑ\82 поможеÑ\82 авÑ\82омаÑ\82иÑ\87еÑ\81ки внеÑ\81Ñ\82и болÑ\8cÑ\88Ñ\83Ñ\8e Ñ\87аÑ\81Ñ\82Ñ\8c необÑ\85одимÑ\8bÑ\85 изменений в код.
+ÐÑ\82оÑ\82 инÑ\81Ñ\82Ñ\80Ñ\83менÑ\82 поможеÑ\82 авÑ\82омаÑ\82иÑ\87еÑ\81ки измениÑ\82Ñ\8c болÑ\8cÑ\88Ñ\83Ñ\8e Ñ\87аÑ\81Ñ\82Ñ\8c кода, коÑ\82оÑ\80Ñ\8bй нÑ\83жно измениÑ\82Ñ\8c.
-Ð\9fоÑ\81ле Ñ\8dÑ\82ого запÑ\83Ñ\81Ñ\82иÑ\82е Ñ\82еÑ\81Ñ\82Ñ\8b и пÑ\80овеÑ\80Ñ\8cÑ\82е, что всё работает. Если да — на этом всё. 😎
+Ð\9fоÑ\81ле Ñ\8dÑ\82ого вÑ\8b можеÑ\82е запÑ\83Ñ\81Ñ\82иÑ\82Ñ\8c Ñ\82еÑ\81Ñ\82Ñ\8b и пÑ\80овеÑ\80иÑ\82Ñ\8c, что всё работает. Если да — на этом всё. 😎
## Pydantic v1 в v2 { #pydantic-v1-in-v2 }
-Pydantic v2 включает всё из Pydantic v1 как подмодуль `pydantic.v1`.
+Pydantic v2 включает всё из Pydantic v1 как подмодуль `pydantic.v1`. Но это больше не поддерживается в версиях Python выше 3.13.
Это означает, что вы можете установить последнюю версию Pydantic v2 и импортировать и использовать старые компоненты Pydantic v1 из этого подмодуля так, как если бы у вас был установлен старый Pydantic v1.
### Поддержка FastAPI для Pydantic v1 внутри v2 { #fastapi-support-for-pydantic-v1-in-v2 }
-Ð\9dаÑ\87инаÑ\8f Ñ\81 FastAPI 0.119.0, еÑ\81Ñ\82Ñ\8c Ñ\82акже Ñ\87аÑ\81Ñ\82иÑ\87наÑ\8f поддеÑ\80жка Pydantic v1 в Ñ\81оÑ\81Ñ\82аве Pydantic v2, чтобы упростить миграцию на v2.
+Ð\9dаÑ\87инаÑ\8f Ñ\81 FastAPI 0.119.0, еÑ\81Ñ\82Ñ\8c Ñ\82акже Ñ\87аÑ\81Ñ\82иÑ\87наÑ\8f поддеÑ\80жка Pydantic v1 изнÑ\83Ñ\82Ñ\80и Pydantic v2, чтобы упростить миграцию на v2.
Таким образом, вы можете обновить Pydantic до последней версии 2 и сменить импорты на подмодуль `pydantic.v1` — во многих случаях всё просто заработает.
style V2Field fill:#f9fff3
```
-В некоторых случаях можно использовать и модели Pydantic v1, и v2 в одной и той же операции пути (обработчике пути) вашего приложения FastAPI:
+В некоторых случаях можно использовать и модели Pydantic v1, и v2 в одной и той же **операции пути** (обработчике пути) вашего приложения FastAPI:
{* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
/// tip | Совет
-Сначала попробуйте `bump-pydantic`. Если тесты проходят и всё работает, вы справились одной командой. ✨
+Сначала попробуйте `bump-pydantic`: если тесты проходят и всё работает, вы справились одной командой. ✨
///
Если `bump-pydantic` не подходит для вашего случая, вы можете использовать поддержку одновременной работы моделей Pydantic v1 и v2 в одном приложении, чтобы мигрировать на Pydantic v2 постепенно.
-СнаÑ\87ала обновиÑ\82е Pydantic до поÑ\81ледней 2-й веÑ\80Ñ\81ии и измениÑ\82е импорты так, чтобы все ваши модели использовали `pydantic.v1`.
+СнаÑ\87ала вÑ\8b можеÑ\82е обновиÑ\82Ñ\8c Pydantic до поÑ\81ледней 2-й веÑ\80Ñ\81ии и измениÑ\82Ñ\8c импорты так, чтобы все ваши модели использовали `pydantic.v1`.
-Ð\97аÑ\82ем наÑ\87ниÑ\82е мигрировать ваши модели с Pydantic v1 на v2 группами, поэтапно. 🚶
+Ð\97аÑ\82ем вÑ\8b можеÑ\82е наÑ\87аÑ\82Ñ\8c мигрировать ваши модели с Pydantic v1 на v2 группами, поэтапно. 🚶
При использовании **Pydantic v2** сгенерированный OpenAPI становится чуть более точным и **корректным**, чем раньше. 😎
-На самом деле, в некоторых случаях в OpenAPI будет даже **две JSON схемы** для одной и той же Pydantic‑модели: для входа и для выхода — в зависимости от наличия **значений по умолчанию**.
+На самом деле, в некоторых случаях в OpenAPI будет даже **две JSON-схемы** для одной и той же Pydantic‑модели: для входа и для выхода — в зависимости от наличия **значений по умолчанию**.
Посмотрим, как это работает, и как это изменить при необходимости.
{* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py hl[19] *}
-â\80¦Ñ\82о, поÑ\81колÑ\8cкÑ\83 Ñ\83 `description` еÑ\81Ñ\82Ñ\8c знаÑ\87ение по Ñ\83молÑ\87аниÑ\8e, даже еÑ\81ли вÑ\8b **ниÑ\87его не веÑ\80нÑ\91Ñ\82е** длÑ\8f Ñ\8dÑ\82ого полÑ\8f, оно вÑ\81Ñ\91 Ñ\80авно бÑ\83деÑ\82 имеÑ\82Ñ\8c Ñ\8dÑ\82о **знаÑ\87ение по Ñ\83молÑ\87аниÑ\8e**.
+…то, поскольку у `description` есть значение по умолчанию, если вы **ничего не вернёте** для этого поля, оно всё равно будет иметь это **значение по умолчанию**.
### Модель для данных ответа { #model-for-output-response-data }
Это означает, что у него **всегда будет какое‑то значение**, просто иногда это значение может быть `None` (или `null` в JSON).
-СледоваÑ\82елÑ\8cно, клиенÑ\82ам, иÑ\81полÑ\8cзÑ\83Ñ\8eÑ\89им ваÑ\88 API, не нÑ\83жно пÑ\80овеÑ\80Ñ\8fÑ\82Ñ\8c налиÑ\87ие Ñ\8dÑ\82ого знаÑ\87ениÑ\8f: они могÑ\83Ñ\82 **иÑ\81Ñ\85одиÑ\82Ñ\8c из Ñ\82ого, Ñ\87Ñ\82о поле вÑ\81егда пÑ\80иÑ\81Ñ\83Ñ\82Ñ\81Ñ\82вÑ\83еÑ\82**, а в некоÑ\82оÑ\80Ñ\8bÑ\85 Ñ\81лÑ\83Ñ\87аÑ\8fÑ\85 имееÑ\82 значение по умолчанию `None`.
+ÐÑ\82о ознаÑ\87аеÑ\82, Ñ\87Ñ\82о клиенÑ\82ам, иÑ\81полÑ\8cзÑ\83Ñ\8eÑ\89им ваÑ\88 API, не нÑ\83жно пÑ\80овеÑ\80Ñ\8fÑ\82Ñ\8c, Ñ\81Ñ\83Ñ\89еÑ\81Ñ\82вÑ\83еÑ\82 ли Ñ\8dÑ\82о знаÑ\87ение или неÑ\82: они могÑ\83Ñ\82 **иÑ\81Ñ\85одиÑ\82Ñ\8c из Ñ\82ого, Ñ\87Ñ\82о поле вÑ\81егда пÑ\80иÑ\81Ñ\83Ñ\82Ñ\81Ñ\82вÑ\83еÑ\82**, но в некоÑ\82оÑ\80Ñ\8bÑ\85 Ñ\81лÑ\83Ñ\87аÑ\8fÑ\85 оно бÑ\83деÑ\82 имеÑ\82Ñ\8c значение по умолчанию `None`.
В OpenAPI это описывается тем, что поле помечается как **обязательное**, поскольку оно всегда присутствует.
Из‑за этого JSON Schema для модели может отличаться в зависимости от использования для **входа** или **выхода**:
-* для **входа** `description` не будет обязательным
+* для **входа** `description` **не будет обязательным**
* для **выхода** оно будет **обязательным** (и при этом может быть `None`, или, в терминах JSON, `null`)
### Выходная модель в документации { #model-for-output-in-docs }
Однако бывают случаи, когда вы хотите иметь **одну и ту же схему для входа и выхода**.
-Ð\93лавнÑ\8bй Ñ\81Ñ\86енаÑ\80ий â\80\94 когда Ñ\83 ваÑ\81 Ñ\83же еÑ\81Ñ\82Ñ\8c Ñ\81генеÑ\80иÑ\80ованнÑ\8bй клиенÑ\82Ñ\81кий код/SDK, и вÑ\8b пока не Ñ\85оÑ\82иÑ\82е обновлÑ\8fÑ\82Ñ\8c веÑ\81Ñ\8c Ñ\8dÑ\82оÑ\82 авÑ\82огенеÑ\80иÑ\80Ñ\83емÑ\8bй код/SDK (Ñ\80ано или поздно вÑ\8b Ñ\8dÑ\82о Ñ\81делаеÑ\82е, но не Ñ\81ейÑ\87аÑ\81).
+Ð\93лавнÑ\8bй Ñ\81Ñ\86енаÑ\80ий â\80\94 когда Ñ\83 ваÑ\81 Ñ\83же еÑ\81Ñ\82Ñ\8c Ñ\81генеÑ\80иÑ\80ованнÑ\8bй клиенÑ\82Ñ\81кий код/SDK, и вÑ\8b пока не Ñ\85оÑ\82иÑ\82е обновлÑ\8fÑ\82Ñ\8c веÑ\81Ñ\8c Ñ\8dÑ\82оÑ\82 авÑ\82огенеÑ\80иÑ\80Ñ\83емÑ\8bй клиенÑ\82Ñ\81кий код/SDK, веÑ\80оÑ\8fÑ\82но, вÑ\8b заÑ\85оÑ\82иÑ\82е Ñ\81делаÑ\82Ñ\8c Ñ\8dÑ\82о в какой-Ñ\82о моменÑ\82, но, возможно, не пÑ\80Ñ\8fмо Ñ\81ейÑ\87аÑ\81.
-В таком случае вы можете отключить эту функциональность в FastAPI с помощью параметра `separate_input_output_schemas=False`.
+В таком случае вы можете отключить эту функциональность в **FastAPI** с помощью параметра `separate_input_output_schemas=False`.
/// info | Информация
### Одна и та же схема для входной и выходной моделей в документации { #same-schema-for-input-and-output-models-in-docs }
-ТепеÑ\80Ñ\8c длÑ\8f Ñ\8dÑ\82ой модели будет одна общая схема и для входа, и для выхода — только `Item`, и в ней `description` будет **не обязательным**:
+Ð\98 Ñ\82епеÑ\80Ñ\8c длÑ\8f модели будет одна общая схема и для входа, и для выхода — только `Item`, и в ней `description` будет **не обязательным**:
<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image05.png">
</div>
-
-Это то же поведение, что и в Pydantic v1. 🤓
</style>
<p align="center">
- <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+ <a href="https://fastapi.tiangolo.com
/ru"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
</p>
<p align="center">
- <em>ФÑ\80еймвоÑ\80к FastAPI: вÑ\8bÑ\81окаÑ\8f пÑ\80оизводиÑ\82елÑ\8cноÑ\81Ñ\82Ñ\8c, пÑ\80оÑ\81Ñ\82 в изÑ\83Ñ\87ении, бÑ\8bÑ\81Ñ\82Ñ\80Ñ\8bй в Ñ\80азÑ\80абоÑ\82ке, готов к продакшн</em>
+ <em>ФÑ\80еймвоÑ\80к FastAPI: вÑ\8bÑ\81окаÑ\8f пÑ\80оизводиÑ\82елÑ\8cноÑ\81Ñ\82Ñ\8c, пÑ\80оÑ\81Ñ\82 в изÑ\83Ñ\87ении, позволÑ\8fеÑ\82 бÑ\8bÑ\81Ñ\82Ñ\80о пиÑ\81аÑ\82Ñ\8c код, готов к продакшн</em>
</p>
<p align="center">
<a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
* **Скорость**: Очень высокая производительность, на уровне **NodeJS** и **Go** (благодаря Starlette и Pydantic). [Один из самых быстрых доступных фреймворков Python](#performance).
* **Быстрота разработки**: Увеличьте скорость разработки фич примерно на 200–300%. *
* **Меньше ошибок**: Сократите примерно на 40% количество ошибок, вызванных человеком (разработчиком). *
-* **Интуитивность**: Отличная поддержка редактора кода. <abbr title="также известное как: автодополнение, IntelliSense">Автозавершение</abbr> везде. Меньше времени на отладку.
+* **Интуитивность**: Отличная поддержка редактора кода. <abbr title="также известное как: автодополнение, автозавершение, IntelliSense">Автозавершение</abbr> везде. Меньше времени на отладку.
* **Простота**: Разработан так, чтобы его было легко использовать и осваивать. Меньше времени на чтение документации.
* **Краткость**: Минимизируйте дублирование кода. Несколько возможностей из каждого объявления параметров. Меньше ошибок.
* **Надежность**: Получите код, готовый к продакшн. С автоматической интерактивной документацией.
---
+## Мини-документальный фильм о FastAPI { #fastapi-mini-documentary }
+
+В конце 2025 года вышел <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">мини-документальный фильм о FastAPI</a>, вы можете посмотреть его онлайн:
+
+<a href="https://www.youtube.com/watch?v=mpR8ngthqiE" target="_blank"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>
+
## **Typer**, FastAPI для CLI { #typer-the-fastapi-of-clis }
<a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
* Получает HTTP-запросы по _путям_ `/` и `/items/{item_id}`.
* Оба _пути_ используют `GET` <em>операции</em> (также известные как HTTP _методы_).
-* _Путь_ `/items/{item_id}` имеет _параметр пути_ `item_id`, который должен быть `int`.
+* _Путь_ `/items/{item_id}` имеет _path-параметр_ `item_id`, который должен быть `int`.
* _Путь_ `/items/{item_id}` имеет необязательный `str` _параметр запроса_ `q`.
### Интерактивная документация API { #interactive-api-docs }
## Пример обновления { #example-upgrade }
-Теперь измените файл `main.py`, чтобы принимать тело запроса из `PUT` запроса.
+Теперь измените файл `main.py`, чтобы принимать тело запроса из `PUT` HTTP-запроса.
-Объявите тело, используя стандартные типы Python, спасибо Pydantic.
+Объявите тело запроса, используя стандартные типы Python, спасибо Pydantic.
```Python hl_lines="4 9-12 25-27"
from typing import Union
Перейдите на <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
-* Интерактивная документация API будет автоматически обновлена, включая новое тело:
+* Интерактивная документация API будет автоматически обновлена, включая новое тело запроса:
Теперь откройте <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
-* Альтернативная документация также отразит новый параметр запроса и тело:
+* Альтернативная документация также отразит новый параметр запроса и тело запроса:
### Подведём итоги { #recap }
-Ð\98Ñ\82ак, вÑ\8b обÑ\8aÑ\8fвлÑ\8fеÑ\82е **один Ñ\80аз** Ñ\82ипÑ\8b паÑ\80амеÑ\82Ñ\80ов, Ñ\82ела запроса и т.д. как параметры функции.
+Ð\98Ñ\82ак, вÑ\8b обÑ\8aÑ\8fвлÑ\8fеÑ\82е **один Ñ\80аз** Ñ\82ипÑ\8b паÑ\80амеÑ\82Ñ\80ов, Ñ\82ело запроса и т.д. как параметры функции.
Вы делаете это с помощью стандартных современных типов Python.
Возвращаясь к предыдущему примеру кода, **FastAPI** будет:
-* Валидировать наличие `item_id` в пути для `GET` и `PUT` запросов.
-* Валидировать, что `item_id` имеет тип `int` для `GET` и `PUT` запросов.
+* Валидировать наличие `item_id` в пути для `GET` и `PUT` HTTP-запросов.
+* Валидировать, что `item_id` имеет тип `int` для `GET` и `PUT` HTTP-запросов.
* Если это не так, клиент увидит полезную понятную ошибку.
-* Проверять, есть ли необязательный параметр запроса с именем `q` (например, `http://127.0.0.1:8000/items/foo?q=somequery`) для `GET` запросов.
+* Проверять, есть ли необязательный параметр запроса с именем `q` (например, `http://127.0.0.1:8000/items/foo?q=somequery`) для `GET` HTTP-запросов.
* Поскольку параметр `q` объявлен с `= None`, он необязателен.
* Без `None` он был бы обязательным (как тело запроса в случае с `PUT`).
-* Для `PUT` запросов к `/items/{item_id}` читать тело запроса как JSON:
+* Для `PUT` HTTP-запросов к `/items/{item_id}` читать тело запроса как JSON:
* Проверять, что есть обязательный атрибут `name`, который должен быть `str`.
* Проверять, что есть обязательный атрибут `price`, который должен быть `float`.
* Проверять, что есть необязательный атрибут `is_offer`, который должен быть `bool`, если он присутствует.
Более полный пример с дополнительными возможностями см. в <a href="https://fastapi.tiangolo.com/ru/tutorial/">Учебник - Руководство пользователя</a>.
-**Осторожно, спойлер**: учебник - руководство включает:
+**Ð\9eÑ\81Ñ\82оÑ\80ожно, Ñ\81пойлеÑ\80**: Ñ\83Ñ\87ебник - Ñ\80Ñ\83ководÑ\81Ñ\82во полÑ\8cзоваÑ\82елÑ\8f вклÑ\8eÑ\87аеÑ\82:
* Объявление **параметров** из других источников: **HTTP-заголовки**, **cookies**, **поля формы** и **файлы**.
* Как задать **ограничения валидации** вроде `maximum_length` или `regex`.
-* Очень мощную и простую в использовании систему **<abbr title="также известная как: компоненты, ресурсы, провайдеры, сервисы, инъекции">внедрения зависимостей</abbr>**.
+* Очень мощную и простую в использовании систему **<abbr title="также известна как: компоненты, ресурсы, провайдеры, сервисы, инъекции">внедрения зависимостей</abbr>**.
* Безопасность и аутентификацию, включая поддержку **OAuth2** с **JWT токенами** и **HTTP Basic** аутентификацию.
* Более продвинутые (но столь же простые) приёмы объявления **глубоко вложенных JSON-моделей** (спасибо Pydantic).
* Интеграцию **GraphQL** с <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> и другими библиотеками.
* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> — обязателен, если вы хотите использовать `TestClient`.
* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> — обязателен, если вы хотите использовать конфигурацию шаблонов по умолчанию.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a>
— обязателен, если вы хотите поддерживать <abbr title="преобразование строки, полученной из HTTP-запроса, в данные Python">«парсинг»</abbr> форм через `request.form()`.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a>
- обязателен, если вы хотите поддерживать <abbr title="преобразование строки, полученной из HTTP-запроса, в данные Python">«парсинг»</abbr> форм через `request.form()`.
Используется FastAPI:
-* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> — сервер, который загружает и обслуживает ваше приложение. Включает `uvicorn[standard]`, содержащий некоторые зависимости (например, `uvloop`), нужные для высокой производительности.
+* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> — сервер, который загружает и «отдаёт» ваше приложение. Включает `uvicorn[standard]`, содержащий некоторые зависимости (например, `uvloop`), нужные для высокой производительности.
* `fastapi-cli[standard]` — чтобы предоставить команду `fastapi`.
* Включает `fastapi-cloud-cli`, который позволяет развернуть ваше приложение FastAPI в <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
-# Большие приложения, в которых много файлов { #bigger-applications-multiple-files }
+# Большие приложения — несколько файлов { #bigger-applications-multiple-files }
При построении приложения или веб-API нам редко удается поместить всё в один файл.
/// tip | Подсказка
-Ð\9eбÑ\80аÑ\82иÑ\82е внимание, Ñ\87Ñ\82о в каждом каÑ\82алоге и подкаÑ\82алоге имееÑ\82Ñ\81Ñ\8f Ñ\84айл `__init__.py`
+Ð\95Ñ\81Ñ\82Ñ\8c неÑ\81колÑ\8cко Ñ\84айлов `__init__.py`: по одномÑ\83 в каждом каÑ\82алоге или подкаÑ\82алоге.
Это как раз то, что позволяет импортировать код из одного файла в другой.
///
-* Всё помещается в каталоге `app`. В нём также находится пустой файл `app/__init__.py`. Таким образом, `app` является "Python-пакетом" (коллекцией модулей Python).
-* Он содержит файл `app/main.py`. Данный файл является частью пакета (т.е. находится внутри каталога, содержащего файл `__init__.py`), и, соответственно, он является модулем пакета: `app.main`.
+* Всё помещается в каталоге `app`. В нём также находится пустой файл `app/__init__.py`. Таким образом, `app` является "Python-пакетом" (коллекцией "Python-модулей"): `app`.
+* Он содержит файл `app/main.py`. Данный файл является частью Python-пакета (т.е. находится внутри каталога, содержащего файл `__init__.py`), и, соответственно, он является модулем этого пакета: `app.main`.
* Он также содержит файл `app/dependencies.py`, который также, как и `app/main.py`, является модулем: `app.dependencies`.
-* Здесь также находится подкаталог `app/routers/`, содержащий `__init__.py`. Он является суб-пакетом: `app.routers`.
-* Файл `app/routers/items.py` находится внутри пакета `app/routers/`. Таким образом, он является суб-модулем: `app.routers.items`.
-* Точно также `app/routers/users.py` является ещё одним суб-модулем: `app.routers.users`.
-* Подкаталог `app/internal/`, содержащий файл `__init__.py`, является ещё одним суб-пакетом: `app.internal`.
-* А файл `app/internal/admin.py` является ещё одним суб-модулем: `app.internal.admin`.
+* Здесь также находится подкаталог `app/routers/`, содержащий `__init__.py`. Он является Python-подпакетом: `app.routers`.
+* Файл `app/routers/items.py` находится внутри пакета `app/routers/`. Таким образом, он является подмодулем: `app.routers.items`.
+* Точно так же `app/routers/users.py` является ещё одним подмодулем: `app.routers.users`.
+* Подкаталог `app/internal/`, содержащий файл `__init__.py`, является ещё одним Python-подпакетом: `app.internal`.
+* А файл `app/internal/admin.py` является ещё одним подмодулем: `app.internal.admin`.
<img src="/img/tutorial/bigger-applications/package.drawio.svg">
Та же самая файловая структура приложения, но с комментариями:
-```
+```bash
.
├── app # "app" пакет
│ ├── __init__.py # этот файл превращает "app" в "Python-пакет"
│ ├── main.py # модуль "main", напр.: import app.main
│ ├── dependencies.py # модуль "dependencies", напр.: import app.dependencies
-│ └── routers # суб-пакет "routers"
-│ │ ├── __init__.py # превращает "routers" в суб-пакет
-│ │ ├── items.py # суб-модуль "items", напр.: import app.routers.items
-│ │ └── users.py # суб-модуль "users", напр.: import app.routers.users
-│ └── internal # суб-пакет "internal"
-│ ├── __init__.py # превращает "internal" в суб-пакет
-│ └── admin.py # суб-модуль "admin", напр.: import app.internal.admin
+│ └── routers # подпакет "routers"
+│ │ ├── __init__.py # превращает "routers" в подпакет
+│ │ ├── items.py # подмодуль "items", напр.: import app.routers.items
+│ │ └── users.py # подмодуль "users", напр.: import app.routers.users
+│ └── internal # подпакет "internal"
+│ ├── __init__.py # превращает "internal" в подпакет
+│ └── admin.py # подмодуль "admin", напр.: import app.internal.admin
```
## `APIRouter` { #apirouter }
-Давайте предположим, что для работы с пользователями используется отдельный файл (суб-модуль) `/app/routers/users.py`.
+Давайте предположим, что для работы с пользователями используется отдельный файл (подмодуль) `/app/routers/users.py`.
-Ð\94лÑ\8f лÑ\83Ñ\87Ñ\88ей оÑ\80ганизаÑ\86ии пÑ\80иложениÑ\8f, вÑ\8b Ñ\85оÑ\82иÑ\82е оÑ\82делиÑ\82Ñ\8c опеÑ\80аÑ\86ии пÑ\83Ñ\82и, Ñ\81вÑ\8fзаннÑ\8bе Ñ\81 полÑ\8cзоваÑ\82елÑ\8fми, оÑ\82 оÑ\81Ñ\82алÑ\8cного кода.
+Ð\92Ñ\8b Ñ\85оÑ\82иÑ\82е оÑ\82делиÑ\82Ñ\8c *опеÑ\80аÑ\86ии пÑ\83Ñ\82и*, Ñ\81вÑ\8fзаннÑ\8bе Ñ\81 полÑ\8cзоваÑ\82елÑ\8fми, оÑ\82 оÑ\81Ñ\82алÑ\8cного кода, Ñ\87Ñ\82обÑ\8b Ñ\81оÑ\85Ñ\80аниÑ\82Ñ\8c поÑ\80Ñ\8fдок.
-Ð\9dо Ñ\82ак, Ñ\87Ñ\82обÑ\8b Ñ\8dÑ\82и опеÑ\80аÑ\86ии по-пÑ\80ежнемÑ\83 оÑ\81Ñ\82авалиÑ\81Ñ\8c Ñ\87аÑ\81Ñ\82Ñ\8cÑ\8e **FastAPI** пÑ\80иложениÑ\8f/веб-API (Ñ\87аÑ\81Ñ\82Ñ\8cÑ\8e одного пакеÑ\82а)
+Ð\9dо Ñ\8dÑ\82о вÑ\81Ñ\91 Ñ\80авно Ñ\87аÑ\81Ñ\82Ñ\8c Ñ\82ого же пÑ\80иложениÑ\8f/веб-API на **FastAPI** (Ñ\87аÑ\81Ñ\82Ñ\8c Ñ\82ого же «Python-пакеÑ\82а»).
-С помощью `APIRouter` вы можете создать *операции пути* (*эндпоинты*) для данного модуля.
+С помощью `APIRouter` вы можете создать *операции пути* для этого модуля.
### Импорт `APIRouter` { #import-apirouter }
-Точно также, как и в случае с классом `FastAPI`, вам нужно импортировать и создать объект класса `APIRouter`.
+Точно так же, как и в случае с классом `FastAPI`, вам нужно импортировать и создать его «экземпляр»:
{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
-### Создание *эндпоинтов* с помощью `APIRouter` { #path-operations-with-apirouter }
+### *Операции пути* с `APIRouter` { #path-operations-with-apirouter }
+
+И затем вы используете его, чтобы объявить ваши *операции пути*.
-Ð\92 далÑ\8cнейÑ\88ем иÑ\81полÑ\8cзÑ\83йÑ\82е `APIRouter` длÑ\8f обÑ\8aÑ\8fвлениÑ\8f *Ñ\8dндпоинÑ\82ов*, Ñ\82оÑ\87но Ñ\82акже, как вÑ\8b иÑ\81полÑ\8cзÑ\83еÑ\82е класс `FastAPI`:
+Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е его Ñ\82ак же, как вÑ\8b иÑ\81полÑ\8cзовали бÑ\8b класс `FastAPI`:
{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
-Вы можете думать об `APIRouter` как об "уменьшенной версии" класса FastAPI`.
+Вы можете думать об `APIRouter` как об «мини-классе `FastAPI`».
-`APIRouter` поддерживает все те же самые опции.
+Поддерживаются все те же опции.
-`APIRouter` поддерживает все те же самые параметры, такие как `parameters`, `responses`, `dependencies`, `tags`, и т. д.
+Все те же `parameters`, `responses`, `dependencies`, `tags` и т.д.
/// tip | Подсказка
///
-Мы собираемся подключить данный `APIRouter` к нашему основному приложению на `FastAPI`, но сначала давайте проверим зависимости и создадим ещё один модуль с `APIRouter`.
+Мы собираемся подключить данный `APIRouter` к нашему основному приложению на `FastAPI`, но сначала давайте проверим зависимости и ещё один `APIRouter`.
## Зависимости { #dependencies }
-Ð\9dам понадобÑ\8fÑ\82Ñ\81Ñ\8f некоÑ\82оÑ\80Ñ\8bе завиÑ\81имоÑ\81Ñ\82и, коÑ\82оÑ\80Ñ\8bе мÑ\8b бÑ\83дем иÑ\81полÑ\8cзоваÑ\82Ñ\8c в Ñ\80азнÑ\8bÑ\85 меÑ\81Ñ\82аÑ\85 наÑ\88его приложения.
+Ð\9cÑ\8b видим, Ñ\87Ñ\82о нам понадобÑ\8fÑ\82Ñ\81Ñ\8f некоÑ\82оÑ\80Ñ\8bе завиÑ\81имоÑ\81Ñ\82и, коÑ\82оÑ\80Ñ\8bе бÑ\83дÑ\83Ñ\82 иÑ\81полÑ\8cзоваÑ\82Ñ\8cÑ\81Ñ\8f в неÑ\81колÑ\8cкиÑ\85 меÑ\81Ñ\82аÑ\85 приложения.
-Ð\9cы поместим их в отдельный модуль `dependencies` (`app/dependencies.py`).
+Ð\9fоÑ\8dÑ\82омÑ\83 мы поместим их в отдельный модуль `dependencies` (`app/dependencies.py`).
-ТепеÑ\80Ñ\8c мÑ\8b воÑ\81полÑ\8cзÑ\83емÑ\81Ñ\8f пÑ\80оÑ\81Ñ\82ой завиÑ\81имоÑ\81Ñ\82Ñ\8cÑ\8e, Ñ\87Ñ\82обÑ\8b пÑ\80оÑ\87иÑ\82аÑ\82Ñ\8c каÑ\81Ñ\82омизиÑ\80ованнÑ\8bй `X-Token` из заголовка:
+ТепеÑ\80Ñ\8c мÑ\8b воÑ\81полÑ\8cзÑ\83емÑ\81Ñ\8f пÑ\80оÑ\81Ñ\82ой завиÑ\81имоÑ\81Ñ\82Ñ\8cÑ\8e, Ñ\87Ñ\82обÑ\8b пÑ\80оÑ\87иÑ\82аÑ\82Ñ\8c каÑ\81Ñ\82омнÑ\8bй HTTP-заголовок `X-Token`:
{* ../../docs_src/bigger_applications/app_an_py39/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
/// tip | Подсказка
-Ð\94лÑ\8f пÑ\80оÑ\81Ñ\82оÑ\82Ñ\8b мÑ\8b воÑ\81полÑ\8cзовалиÑ\81Ñ\8c неким вообÑ\80ажаемÑ\8bм заголовоком.
+Ð\94лÑ\8f пÑ\80оÑ\81Ñ\82оÑ\82Ñ\8b мÑ\8b воÑ\81полÑ\8cзовалиÑ\81Ñ\8c вÑ\8bдÑ\83маннÑ\8bм заголовком.
В реальных случаях для получения наилучших результатов используйте интегрированные [утилиты безопасности](security/index.md){.internal-link target=_blank}.
## Ещё один модуль с `APIRouter` { #another-module-with-apirouter }
-Давайте также предположим, что у вас есть *эндпоинты*, отвечающие за обработку "items", и они находятся в модуле `app/routers/items.py`.
+Давайте также предположим, что у вас есть эндпоинты, отвечающие за обработку «items» в вашем приложении, и они находятся в модуле `app/routers/items.py`.
-У вас определены следующие *операции пути* (*эндпоинты*):
+У вас определены *операции пути* для:
* `/items/`
* `/items/{item_id}`
-ТÑ\83Ñ\82 вÑ\81Ñ\91 Ñ\82оÑ\87но Ñ\82акже, как и в Ñ\81иÑ\82Ñ\83аÑ\86ии с `app/routers/users.py`.
+ТÑ\83Ñ\82 вÑ\81Ñ\91 Ñ\82а же Ñ\81Ñ\82Ñ\80Ñ\83кÑ\82Ñ\83Ñ\80а, как и в Ñ\81лÑ\83Ñ\87ае с `app/routers/users.py`.
-Но теперь мы хотим поступить немного умнее и слегка упростить код.
+Но мы хотим поступить умнее и слегка упростить код.
-Мы знаем, что все *эндпоинты* данного модуля имеют некоторые общие свойства:
+Мы знаем, что все *операции пути* этого модуля имеют одинаковые:
-* Префикс пути: `/items`.
-* Теги: (один единственный тег: `items`).
-* Дополнительные ответы (responses)
-* Зависимости: использование созданной нами зависимости `X-token`
+* `prefix` пути: `/items`.
+* `tags`: (один единственный тег: `items`).
+* Дополнительные `responses`.
+* `dependencies`: всем им нужна та зависимость `X-Token`, которую мы создали.
-Таким образом, вместо того чтобы добавлять все эти свойства в функцию каждого отдельного *эндпоинта*,
-мы добавим их в `APIRouter`.
+Таким образом, вместо того чтобы добавлять всё это в каждую *операцию пути*, мы можем добавить это в `APIRouter`.
{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
-Так как каждÑ\8bй *Ñ\8dндпоинÑ\82* наÑ\87инаеÑ\82Ñ\81Ñ\8f Ñ\81 Ñ\81имвола `/`:
+Так как пÑ\83Ñ\82Ñ\8c каждой *опеÑ\80аÑ\86ии пÑ\83Ñ\82и* должен наÑ\87инаÑ\82Ñ\8cÑ\81Ñ\8f Ñ\81 `/`, как здеÑ\81Ñ\8c:
```Python hl_lines="1"
@router.get("/{item_id}")
В нашем случае префиксом является `/items`.
-Мы также можем добавить в наш маршрутизатор (router) список `тегов` (`tags`) и дополнительных `ответов` (`responses`), которые являются общими для каждого *эндпоинта*.
+Мы также можем добавить список `tags` и дополнительные `responses`, которые будут применяться ко всем *операциям пути*, включённым в этот маршрутизатор.
-И ещё мы можем добавить в наш маршрутизатор список `зависимостей`, которые должны вызываться при каждом обращении к *эндпоинтам*.
+И ещё мы можем добавить список `dependencies`, которые будут добавлены ко всем *операциям пути* в маршрутизаторе и будут выполняться/разрешаться для каждого HTTP-запроса к ним.
/// tip | Подсказка
-Обратите внимание, что также, как и в случае с зависимостями в декораторах *эндпоинтов* ([зависимости в декораторах операций пути](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), никакого значения в *функцию эндпоинта* передано не будет.
+Обратите внимание, что так же, как и в случае с [зависимостями в декораторах *операций пути*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, никакое значение не будет передано в вашу *функцию-обработчик пути*.
///
-Ð\92 Ñ\80езÑ\83лÑ\8cÑ\82аÑ\82е мÑ\8b полÑ\83Ñ\87им Ñ\81ледÑ\83Ñ\8eÑ\89ие Ñ\8dндпоинÑ\82Ñ\8b:
+Ð\92 Ñ\80езÑ\83лÑ\8cÑ\82аÑ\82е пÑ\83Ñ\82и длÑ\8f items Ñ\82епеÑ\80Ñ\8c Ñ\82акие:
* `/items/`
* `/items/{item_id}`
...как мы и планировали.
-* Ð\9eни бÑ\83дÑ\83Ñ\82 помеÑ\87енÑ\8b Ñ\82егами из заданного Ñ\81пиÑ\81ка, в наÑ\88ем Ñ\81лÑ\83Ñ\87ае Ñ\8dÑ\82о `"items"`.
- * Эти теги особенно полезны для системы автоматической интерактивной документации (с использованием OpenAPI).
-* Ð\9aаждÑ\8bй из ниÑ\85 бÑ\83деÑ\82 вклÑ\8eÑ\87аÑ\82Ñ\8c пÑ\80едопÑ\80еделеннÑ\8bе оÑ\82веÑ\82Ñ\8b `responses`.
-* Ð\9aаждÑ\8bй *Ñ\8dндпоинÑ\82* бÑ\83деÑ\82 имеÑ\82Ñ\8c Ñ\81пиÑ\81ок завиÑ\81имоÑ\81Ñ\82ей (`dependencies`), иÑ\81полнÑ\8fемÑ\8bÑ\85 пеÑ\80ед вÑ\8bзовом *Ñ\8dндпоинÑ\82а*.
- * Если вы определили зависимости в самой операции пути, **то она также будет выполнена**.
- * Сначала выполняются зависимости маршрутизатора, затем вызываются [зависимости в декораторе](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, и, наконец, обычные параметрические зависимости.
- * Вы также можете добавить [зависимости `Security` с `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+* Ð\9eни бÑ\83дÑ\83Ñ\82 помеÑ\87енÑ\8b Ñ\81пиÑ\81ком Ñ\82егов, Ñ\81одеÑ\80жаÑ\89им однÑ\83 Ñ\81Ñ\82Ñ\80окÑ\83 `"items"`.
+ * Эти «теги» особенно полезны для систем автоматической интерактивной документации (с использованием OpenAPI).
+* Ð\92Ñ\81е они бÑ\83дÑ\83Ñ\82 вклÑ\8eÑ\87аÑ\82Ñ\8c пÑ\80едопÑ\80еделÑ\91ннÑ\8bе `responses`.
+* Ð\92Ñ\81е Ñ\8dÑ\82и *опеÑ\80аÑ\86ии пÑ\83Ñ\82и* бÑ\83дÑ\83Ñ\82 имеÑ\82Ñ\8c Ñ\81пиÑ\81ок `dependencies`, вÑ\8bÑ\87иÑ\81лÑ\8fемÑ\8bÑ\85/вÑ\8bполнÑ\8fемÑ\8bÑ\85 пеÑ\80ед ними.
+ * Если вы также объявите зависимости в конкретной *операции пути*, **они тоже будут выполнены**.
+ * Сначала выполняются зависимости маршрутизатора, затем [`dependencies` в декораторе](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, и затем обычные параметрические зависимости.
+ * Вы также можете добавить [`Security`-зависимости с `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
/// tip | Подсказка
-Например, с помощью зависимостей в `APIRouter` мы можем потребовать аутентификации для доступа ко всей группе *эндпоинтов*, не указывая зависимости для каждой отдельной функции *эндпоинта*.
+Например, с помощью зависимостей в `APIRouter` мы можем потребовать аутентификации для доступа ко всей группе *операций пути*. Даже если зависимости не добавляются по отдельности к каждой из них.
///
/// check | Заметка
-Параметры `prefix`, `tags`, `responses` и `dependencies` относятся к функционалу **FastAPI**, помогающему избежать дублирования кода.
+Параметры `prefix`, `tags`, `responses` и `dependencies` — это (как и во многих других случаях) просто возможность **FastAPI**, помогающая избежать дублирования кода.
///
### Импорт зависимостей { #import-the-dependencies }
-Ð\9dаÑ\88 код наÑ\85одиÑ\82Ñ\81Ñ\8f в модÑ\83ле `app.routers.items` (Ñ\84айл `app/routers/items.py`).
+ÐÑ\82оÑ\82 код наÑ\85одиÑ\82Ñ\81Ñ\8f в модÑ\83ле `app.routers.items`, в Ñ\84айле `app/routers/items.py`.
-Ð\98 нам нÑ\83жно вÑ\8bзваÑ\82Ñ\8c Ñ\84Ñ\83нкÑ\86иÑ\8e завиÑ\81имоÑ\81Ñ\82и из модÑ\83лÑ\8f `app.dependencies` (Ñ\84айл `app/dependencies.py`).
+Ð\98 нам нÑ\83жно полÑ\83Ñ\87иÑ\82Ñ\8c Ñ\84Ñ\83нкÑ\86иÑ\8e завиÑ\81имоÑ\81Ñ\82и из модÑ\83лÑ\8f `app.dependencies`, Ñ\84айла `app/dependencies.py`.
-Ð\9cÑ\8b иÑ\81полÑ\8cзÑ\83ем опеÑ\80аÑ\86иÑ\8e оÑ\82ноÑ\81иÑ\82елÑ\8cного импоÑ\80Ñ\82а `..` длÑ\8f импоÑ\80Ñ\82а завиÑ\81имоÑ\81Ñ\82и:
+Ð\9fоÑ\8dÑ\82омÑ\83 мÑ\8b иÑ\81полÑ\8cзÑ\83ем оÑ\82ноÑ\81иÑ\82елÑ\8cнÑ\8bй импоÑ\80Ñ\82 Ñ\81 `..` длÑ\8f завиÑ\81имоÑ\81Ñ\82ей:
{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[3] title["app/routers/items.py"] *}
-#### Как работает относительный импорт? { #how-relative-imports-work }
+#### Как работает относительный импорт { #how-relative-imports-work }
/// tip | Подсказка
-Если вы прекрасно знаете, как работает импорт в Python, то переходите к следующему разделу.
+Если вы прекрасно знаете, как работает импорт, переходите к следующему разделу ниже.
///
-Ð\9eдна Ñ\82оÑ\87ка `.`, как в данном пÑ\80имеÑ\80е:
+Ð\9eдна Ñ\82оÑ\87ка `.`, как здеÑ\81Ñ\8c:
```Python
from .dependencies import get_token_header
```
+
означает:
-* Ð\9dаÑ\87ниÑ\82е Ñ\81 пакеÑ\82а, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f даннÑ\8bй модÑ\83лÑ\8c (Ñ\84айл `app/routers/items.py` Ñ\80аÑ\81положен в каÑ\82алоге `app/routers/`)...
-* ... найдите модуль `dependencies` (файл `app/routers/dependencies.py`)...
-* ... и импортируйте из него функцию `get_token_header`.
+* Ð\9dаÑ\87аÑ\82Ñ\8c в Ñ\82ом же пакеÑ\82е, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f Ñ\8dÑ\82оÑ\82 модÑ\83лÑ\8c (Ñ\84айл `app/routers/items.py`) (каÑ\82алог `app/routers/`)...
+* найти модуль `dependencies` (воображаемый файл `app/routers/dependencies.py`)...
+* и импортировать из него функцию `get_token_header`.
-Ð\9a Ñ\81ожалениÑ\8e, Ñ\82акого Ñ\84айла не Ñ\81Ñ\83Ñ\89еÑ\81Ñ\82вÑ\83еÑ\82, и наши зависимости находятся в файле `app/dependencies.py`.
+Ð\9dо Ñ\82акого Ñ\84айла не Ñ\81Ñ\83Ñ\89еÑ\81Ñ\82вÑ\83еÑ\82, наши зависимости находятся в файле `app/dependencies.py`.
Вспомните, как выглядит файловая структура нашего приложения:
---
-Ð\94ве Ñ\82оÑ\87ки `..`, как в данном пÑ\80имеÑ\80е:
+Ð\94ве Ñ\82оÑ\87ки `..`, как здеÑ\81Ñ\8c:
```Python
from ..dependencies import get_token_header
означают:
-* Ð\9dаÑ\87ниÑ\82е Ñ\81 пакеÑ\82а, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f даннÑ\8bй модÑ\83лÑ\8c (Ñ\84айл `app/routers/items.py` наÑ\85одиÑ\82Ñ\81Ñ\8f в каÑ\82алоге `app/routers/`)...
-* ... перейдите в родительский пакет (каталог `app/`)...
-* ... найдите в нём модуль `dependencies` (файл `app/dependencies.py`)...
-* ... и импортируйте из него функцию `get_token_header`.
+* Ð\9dаÑ\87аÑ\82Ñ\8c в Ñ\82ом же пакеÑ\82е, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f Ñ\8dÑ\82оÑ\82 модÑ\83лÑ\8c (Ñ\84айл `app/routers/items.py`) (каÑ\82алог `app/routers/`)...
+* перейти в родительский пакет (каталог `app/`)...
+* и там найти модуль `dependencies` (файл `app/dependencies.py`)...
+* и импортировать из него функцию `get_token_header`.
-ÐÑ\82о Ñ\80абоÑ\82аеÑ\82 веÑ\80но! 🎉
+ÐÑ\82о Ñ\80абоÑ\82аеÑ\82 коÑ\80Ñ\80екÑ\82но! 🎉
---
то это бы означало:
-* Ð\9dаÑ\87ниÑ\82е Ñ\81 пакеÑ\82а, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f даннÑ\8bй модÑ\83лÑ\8c (Ñ\84айл `app/routers/items.py` наÑ\85одиÑ\82Ñ\81Ñ\8f в каталоге `app/routers/`)...
-* ... перейдите в родительский пакет (каталог `app/`)...
-* ... затем перейдите в родительский пакет текущего пакета (такого пакета не существует, `app` находится на самом верхнем уровне 😱)...
-* ... найдите в нём модуль `dependencies` (файл `app/dependencies.py`)...
-* ... и импортируйте из него функцию `get_token_header`.
+* Ð\9dаÑ\87аÑ\82Ñ\8c в Ñ\82ом же пакеÑ\82е, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f Ñ\8dÑ\82оÑ\82 модÑ\83лÑ\8c (Ñ\84айл `app/routers/items.py`) Ñ\80аÑ\81положен в (каталоге `app/routers/`)...
+* перейти в родительский пакет (каталог `app/`)...
+* затем перейти в родительский пакет этого пакета (родительского пакета нет, `app` — верхний уровень 😱)...
+* и там найти модуль `dependencies` (файл `app/dependencies.py`)...
+* и импортировать из него функцию `get_token_header`.
-Это будет относиться к некоторому пакету, находящемуся на один уровень выше чем `app/` и содержащему свой собственный файл `__init__.py`. Но ничего такого у нас нет. Поэтому это приведет к ошибке в нашем примере. 🚨
+Это ссылалось бы на какой-то пакет выше `app/`, со своим файлом `__init__.py` и т.п. Но у нас такого нет. Поэтому это вызвало бы ошибку в нашем примере. 🚨
-ТепеÑ\80Ñ\8c вÑ\8b знаеÑ\82е, как Ñ\80абоÑ\82аеÑ\82 импоÑ\80Ñ\82 в Python, и Ñ\81можеÑ\82е иÑ\81полÑ\8cзоваÑ\82Ñ\8c оÑ\82ноÑ\81иÑ\82елÑ\8cное импоÑ\80Ñ\82иÑ\80ование в Ñ\81воиÑ\85 Ñ\81обÑ\81Ñ\82веннÑ\8bÑ\85 пÑ\80иложениÑ\8fÑ\85 лÑ\8eбого Ñ\83Ñ\80овнÑ\8f Ñ\81ложноÑ\81Ñ\82и. 🤓
+Ð\9dо Ñ\82епеÑ\80Ñ\8c вÑ\8b знаеÑ\82е, как Ñ\8dÑ\82о Ñ\80абоÑ\82аеÑ\82, Ñ\82ак Ñ\87Ñ\82о можеÑ\82е иÑ\81полÑ\8cзоваÑ\82Ñ\8c оÑ\82ноÑ\81иÑ\82елÑ\8cнÑ\8bе импоÑ\80Ñ\82Ñ\8b в Ñ\81воиÑ\85 пÑ\80иложениÑ\8fÑ\85, незавиÑ\81имо оÑ\82 Ñ\82ого, наÑ\81колÑ\8cко они Ñ\81ложнÑ\8bе. 🤓
-### Добавление пользовательских тегов (`tags`), ответов (`responses`) и зависимостей (`dependencies`) { #add-some-custom-tags-responses-and-dependencies }
+### Добавление пользовательских `tags`, `responses` и `dependencies` { #add-some-custom-tags-responses-and-dependencies }
-Ð\9cÑ\8b не бÑ\83дем добавлÑ\8fÑ\82Ñ\8c пÑ\80еÑ\84икÑ\81 `/items` и Ñ\81пиÑ\81ок Ñ\82егов `tags=["items"]` длÑ\8f каждого *Ñ\8dндпоинÑ\82а*, Ñ\82.к. мÑ\8b Ñ\83же иÑ\85 добавили Ñ\81 помоÑ\89Ñ\8cÑ\8e `APIRouter`.
+Ð\9cÑ\8b не добавлÑ\8fем пÑ\80еÑ\84икÑ\81 `/items` и `tags=["items"]` к каждой *опеÑ\80аÑ\86ии пÑ\83Ñ\82и*, поÑ\82омÑ\83 Ñ\87Ñ\82о мÑ\8b добавили иÑ\85 в `APIRouter`.
-Ð\9dо помимо Ñ\8dÑ\82ого мÑ\8b можем добавиÑ\82Ñ\8c новÑ\8bе Ñ\82еги длÑ\8f каждого оÑ\82делÑ\8cного *Ñ\8dндпоинÑ\82а*, а Ñ\82акже некоÑ\82оÑ\80Ñ\8bе дополниÑ\82елÑ\8cнÑ\8bе оÑ\82веÑ\82Ñ\8b (`responses`), Ñ\85аÑ\80акÑ\82еÑ\80нÑ\8bе длÑ\8f данного *Ñ\8dндпоинÑ\82а*:
+Ð\9dо мÑ\8b вÑ\81Ñ\91 Ñ\80авно можем добавиÑ\82Ñ\8c _еÑ\89Ñ\91_ `tags`, коÑ\82оÑ\80Ñ\8bе бÑ\83дÑ\83Ñ\82 пÑ\80именÑ\8fÑ\82Ñ\8cÑ\81Ñ\8f к конкÑ\80еÑ\82ной *опеÑ\80аÑ\86ии пÑ\83Ñ\82и*, а Ñ\82акже дополниÑ\82елÑ\8cнÑ\8bе `responses`, Ñ\81пеÑ\86иÑ\84иÑ\87нÑ\8bе длÑ\8f Ñ\8dÑ\82ой *опеÑ\80аÑ\86ии пÑ\83Ñ\82и*:
{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[30:31] title["app/routers/items.py"] *}
/// tip | Подсказка
-Ð\9fоÑ\81ледний *Ñ\8dндпоинÑ\82* бÑ\83деÑ\82 имеÑ\82Ñ\8c Ñ\81ледÑ\83Ñ\8eÑ\89Ñ\83Ñ\8e комбинацию тегов: `["items", "custom"]`.
+ÐÑ\82а поÑ\81леднÑ\8fÑ\8f опеÑ\80аÑ\86иÑ\8f пÑ\83Ñ\82и бÑ\83деÑ\82 имеÑ\82Ñ\8c комбинацию тегов: `["items", "custom"]`.
-Ð\90 Ñ\82акже в его докÑ\83менÑ\82аÑ\86ии бÑ\83дÑ\83Ñ\82 Ñ\81одеÑ\80жаÑ\82Ñ\8cÑ\81Ñ\8f оба оÑ\82веÑ\82а: один длÑ\8f `404` и дÑ\80Ñ\83гой для `403`.
+Ð\98 в докÑ\83менÑ\82аÑ\86ии Ñ\83 неÑ\91 бÑ\83дÑ\83Ñ\82 оба оÑ\82веÑ\82а: один длÑ\8f `404` и один для `403`.
///
Именно сюда вы импортируете и именно здесь вы используете класс `FastAPI`.
-Это основной файл вашего приложения, который объединяет всё в одно целое.
+Это основной файл вашего приложения, который связывает всё воедино.
-Ð\98 Ñ\82епеÑ\80Ñ\8c, когда болÑ\8cÑ\88аÑ\8f Ñ\87аÑ\81Ñ\82Ñ\8c логики пÑ\80иложениÑ\8f Ñ\80азделена на оÑ\82делÑ\8cнÑ\8bе модÑ\83ли, оÑ\81новной Ñ\84айл `app/main.py` бÑ\83деÑ\82 доÑ\81Ñ\82аÑ\82оÑ\87но простым.
+Ð\98 Ñ\82ак как болÑ\8cÑ\88аÑ\8f Ñ\87аÑ\81Ñ\82Ñ\8c ваÑ\88ей логики Ñ\82епеÑ\80Ñ\8c бÑ\83деÑ\82 наÑ\85одиÑ\82Ñ\8cÑ\81Ñ\8f в оÑ\82делÑ\8cнÑ\8bÑ\85 Ñ\81пеÑ\86иÑ\84иÑ\87нÑ\8bÑ\85 модÑ\83лÑ\8fÑ\85, оÑ\81новной Ñ\84айл бÑ\83деÑ\82 доволÑ\8cно простым.
### Импорт `FastAPI` { #import-fastapi }
-Вы импортируете и создаете класс `FastAPI` как обычно.
+Вы импортируете и создаёте класс `FastAPI` как обычно.
-Ð\9cÑ\8b даже можем обÑ\8aÑ\8fвиÑ\82Ñ\8c [глобалÑ\8cнÑ\8bе завиÑ\81имоÑ\81Ñ\82и](dependencies/global-dependencies.md){.internal-link target=_blank}, коÑ\82оÑ\80Ñ\8bе бÑ\83дÑ\83Ñ\82 обÑ\8aединенÑ\8b Ñ\81 завиÑ\81имоÑ\81Ñ\82Ñ\8fми длÑ\8f каждого оÑ\82делÑ\8cного маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80а:
+Ð\98 мÑ\8b даже можем обÑ\8aÑ\8fвиÑ\82Ñ\8c [глобалÑ\8cнÑ\8bе завиÑ\81имоÑ\81Ñ\82и](dependencies/global-dependencies.md){.internal-link target=_blank}, коÑ\82оÑ\80Ñ\8bе бÑ\83дÑ\83Ñ\82 обÑ\8aединенÑ\8b Ñ\81 завиÑ\81имоÑ\81Ñ\82Ñ\8fми длÑ\8f каждого `APIRouter`:
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[1,3,7] title["app/main.py"] *}
### Импорт `APIRouter` { #import-the-apirouter }
-Теперь мы импортируем другие суб-модули, содержащие `APIRouter`:
+Теперь мы импортируем другие подмодули, содержащие `APIRouter`:
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[4:5] title["app/main.py"] *}
-Так как файлы `app/routers/users.py` и `app/routers/items.py` являются суб-модулями одного и того же Python-пакета `app`, то мы сможем их импортировать, воспользовавшись операцией относительного импорта `.`.
+Так как файлы `app/routers/users.py` и `app/routers/items.py` являются подмодулями, входящими в один и тот же Python-пакет `app`, мы можем использовать одну точку `.` для импорта через «относительные импорты».
-### Как работает импорт? { #how-the-importing-works }
+### Как работает импорт { #how-the-importing-works }
-Ð\94аннаÑ\8f Ñ\81Ñ\82Ñ\80ока кода:
+ÐÑ\82оÑ\82 Ñ\84Ñ\80агменÑ\82:
```Python
from .routers import items, users
означает:
-* Ð\9dаÑ\87ниÑ\82е Ñ\81 пакеÑ\82а, в коÑ\82оÑ\80ом Ñ\81одеÑ\80жиÑ\82Ñ\81Ñ\8f даннÑ\8bй модÑ\83лÑ\8c (Ñ\84айл `app/main.py` Ñ\81одеÑ\80жиÑ\82Ñ\81Ñ\8f в каталоге `app/`)...
-* ... найдите суб-пакет `routers` (каталог `app/routers/`)...
-* ... и из него импортируйте суб-модули `items` (файл `app/routers/items.py`) и `users` (файл `app/routers/users.py`)...
+* Ð\9dаÑ\87аÑ\82Ñ\8c в Ñ\82ом же пакеÑ\82е, в коÑ\82оÑ\80ом наÑ\85одиÑ\82Ñ\81Ñ\8f Ñ\8dÑ\82оÑ\82 модÑ\83лÑ\8c (Ñ\84айл `app/main.py`) Ñ\80аÑ\81положен в (каталоге `app/`)...
+* найти подпакет `routers` (каталог `app/routers/`)...
+* и импортировать из него подмодули `items` (файл `app/routers/items.py`) и `users` (файл `app/routers/users.py`)...
-В модуле `items` содержится переменная `router` (`items.router`), та самая, которую мы создали в файле `app/routers/items.py`, она является объектом класса `APIRouter`.
+В модуле `items` будет переменная `router` (`items.router`). Это та же самая, которую мы создали в файле `app/routers/items.py`, это объект `APIRouter`.
-И затем мы сделаем то же самое для модуля `users`.
+И затем мы делаем то же самое для модуля `users`.
-Мы также могли бы импортировать и другим методом:
+Мы также могли бы импортировать их так:
```Python
from app.routers import items, users
/// info | Примечание
-Первая версия является примером относительного импорта:
+Первая версия — это «относительный импорт»:
```Python
from .routers import items, users
```
-Вторая версия является примером абсолютного импорта:
+Вторая версия — это «абсолютный импорт»:
```Python
from app.routers import items, users
```
-УзнаÑ\82Ñ\8c болÑ\8cÑ\88е о пакеÑ\82аÑ\85 и модÑ\83лÑ\8fÑ\85 в Python вÑ\8b можеÑ\82е из <a href="https://docs.python.org/3/tutorial/modules.html" class="external-link" target="_blank">оÑ\84иÑ\86иалÑ\8cной докÑ\83менÑ\82аÑ\86ии Python о модÑ\83лÑ\8fÑ\85</a>
+ЧÑ\82обÑ\8b Ñ\83знаÑ\82Ñ\8c болÑ\8cÑ\88е о Python-пакеÑ\82аÑ\85 и модÑ\83лÑ\8fÑ\85, пÑ\80оÑ\87иÑ\82айÑ\82е <a href="https://docs.python.org/3/tutorial/modules.html" class="external-link" target="_blank">оÑ\84иÑ\86иалÑ\8cнÑ\83Ñ\8e докÑ\83менÑ\82аÑ\86иÑ\8e Python о модÑ\83лÑ\8fÑ\85</a>.
///
-### Избегайте конфликтов имен { #avoid-name-collisions }
+### Избегайте конфликтов имён { #avoid-name-collisions }
-Ð\92меÑ\81Ñ\82о Ñ\82ого Ñ\87Ñ\82обÑ\8b импоÑ\80Ñ\82иÑ\80оваÑ\82Ñ\8c Ñ\82олÑ\8cко пеÑ\80еменнÑ\83Ñ\8e `router`, мÑ\8b импоÑ\80Ñ\82иÑ\80Ñ\83ем непоÑ\81Ñ\80едÑ\81Ñ\82венно Ñ\81Ñ\83б-модÑ\83лÑ\8c `items`.
+Ð\9cÑ\8b импоÑ\80Ñ\82иÑ\80Ñ\83ем подмодÑ\83лÑ\8c `items` напÑ\80Ñ\8fмÑ\83Ñ\8e, вмеÑ\81Ñ\82о Ñ\82ого Ñ\87Ñ\82обÑ\8b импоÑ\80Ñ\82иÑ\80оваÑ\82Ñ\8c Ñ\82олÑ\8cко его пеÑ\80еменнÑ\83Ñ\8e `router`.
-Ð\9cÑ\8b делаем Ñ\8dÑ\82о поÑ\82омÑ\83, Ñ\87Ñ\82о Ñ\83 наÑ\81 еÑ\81Ñ\82Ñ\8c еÑ\89Ñ\91 одна пеÑ\80еменнаÑ\8f `router` в Ñ\81Ñ\83б-модуле `users`.
+ÐÑ\82о поÑ\82омÑ\83, Ñ\87Ñ\82о Ñ\83 наÑ\81 Ñ\82акже еÑ\81Ñ\82Ñ\8c дÑ\80Ñ\83гаÑ\8f пеÑ\80еменнаÑ\8f Ñ\81 именем `router` в подмодуле `users`.
-Ð\95Ñ\81ли бÑ\8b мÑ\8b импоÑ\80Ñ\82иÑ\80овали иÑ\85 однÑ\83 за дÑ\80Ñ\83гой, как показано в пÑ\80имеÑ\80е:
+Ð\95Ñ\81ли бÑ\8b мÑ\8b импоÑ\80Ñ\82иÑ\80овали иÑ\85 однÑ\83 за дÑ\80Ñ\83гой, как здеÑ\81Ñ\8c:
```Python
from .routers.items import router
from .routers.users import router
```
-то переменная `router` из `users` переписал бы переменную `router` из `items`, и у нас не было бы возможности использовать их одновременно.
+то `router` из `users` перезаписал бы `router` из `items`, и мы не смогли бы использовать их одновременно.
-Поэтому, для того чтобы использовать обе эти переменные в одном файле, мы импортировали соответствующие суб-модули:
+Поэтому, чтобы иметь возможность использовать обе в одном файле, мы импортируем подмодули напрямую:
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
-### Подключение маршрутизаторов (`APIRouter`) для `users` и для `items` { #include-the-apirouters-for-users-and-items }
+### Подключение `APIRouter` для `users` и `items` { #include-the-apirouters-for-users-and-items }
-Ð\94авайÑ\82е подклÑ\8eÑ\87им маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80Ñ\8b (`router`) из Ñ\81Ñ\83б-модулей `users` и `items`:
+ТепеÑ\80Ñ\8c давайÑ\82е подклÑ\8eÑ\87им `router` из подмодулей `users` и `items`:
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[10:11] title["app/main.py"] *}
///
-С помощью `app.include_router()` мы можем добавить каждый из маршрутизаторов (`APIRouter`) в основное приложение `FastAPI`.
+С помощью `app.include_router()` мы можем добавить каждый `APIRouter` в основное приложение `FastAPI`.
-Ð\9eн подклÑ\8eÑ\87иÑ\82 вÑ\81е маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82Ñ\8b заданного маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80а к наÑ\88емÑ\83 пÑ\80иложениÑ\8e.
+Ð\9eн вклÑ\8eÑ\87иÑ\82 вÑ\81е маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82Ñ\8b Ñ\8dÑ\82ого маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80а как Ñ\87аÑ\81Ñ\82Ñ\8c пÑ\80иложениÑ\8f.
/// note | Технические детали
-Фактически, внутри он создаст все *операции пути* для каждой операции пути объявленной в `APIRouter`.
+Фактически, внутри он создаст *операцию пути* для каждой *операции пути*, объявленной в `APIRouter`.
-Ð\98 под капоÑ\82ом вÑ\81Ñ\91 бÑ\83деÑ\82 Ñ\80абоÑ\82аÑ\82Ñ\8c Ñ\82ак, как бÑ\83дÑ\82о бÑ\8b мÑ\8b имеем дело Ñ\81 одним Ñ\84айлом пÑ\80иложениÑ\8f.
+Так Ñ\87Ñ\82о под капоÑ\82ом вÑ\81Ñ\91 бÑ\83деÑ\82 Ñ\80абоÑ\82аÑ\82Ñ\8c Ñ\82ак, как бÑ\83дÑ\82о вÑ\81Ñ\91 бÑ\8bло одним пÑ\80иложением.
///
/// check | Заметка
-При подключении маршрутизаторов не стоит беспокоиться о производительности.
+При подключении маршрутизаторов не нужно беспокоиться о производительности.
-Ð\9eпеÑ\80аÑ\86иÑ\8f подклÑ\8eÑ\87ениÑ\8f займÑ\91Ñ\82 микÑ\80оÑ\81екÑ\83ндÑ\8b и понадобиÑ\82Ñ\81Ñ\8f Ñ\82олÑ\8cко пÑ\80и запÑ\83Ñ\81ке пÑ\80иложениÑ\8f.
+ÐÑ\82о займÑ\91Ñ\82 микÑ\80оÑ\81екÑ\83ндÑ\8b и пÑ\80оизойдÑ\91Ñ\82 Ñ\82олÑ\8cко пÑ\80и Ñ\81Ñ\82аÑ\80Ñ\82е.
-Таким образом, это не повлияет на производительность. ⚡
+Так что это не повлияет на производительность. ⚡
///
-### Подключение `APIRouter` с пользовательскими префиксом (`prefix`), тегами (`tags`), ответами (`responses`), и зависимостями (`dependencies`) { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
+### Подключение `APIRouter` с пользовательскими `prefix`, `tags`, `responses` и `dependencies` { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
Теперь давайте представим, что ваша организация передала вам файл `app/internal/admin.py`.
-Он содержит `APIRouter` с некоторыми *эндпоитами* администрирования, которые ваша организация использует для нескольких проектов.
+Он содержит `APIRouter` с некоторыми административными *операциями пути*, которые ваша организация использует в нескольких проектах.
-В данном примере это сделать очень просто. Но давайте предположим, что поскольку файл используется для нескольких проектов,
-то мы не можем модифицировать его, добавляя префиксы (`prefix`), зависимости (`dependencies`), теги (`tags`), и т.д. непосредственно в `APIRouter`:
+Для этого примера всё будет очень просто. Но допустим, что поскольку он используется совместно с другими проектами в организации, мы не можем модифицировать его и добавить `prefix`, `dependencies`, `tags` и т.д. непосредственно в `APIRouter`:
{* ../../docs_src/bigger_applications/app_an_py39/internal/admin.py hl[3] title["app/internal/admin.py"] *}
-Но, несмотря на это, мы хотим использовать кастомный префикс (`prefix`) для подключенного маршрутизатора (`APIRouter`), в результате чего, каждая *операция пути* будет начинаться с `/admin`. Также мы хотим защитить наш маршрутизатор с помощью зависимостей, созданных для нашего проекта. И ещё мы хотим включить теги (`tags`) и ответы (`responses`).
+Но мы всё равно хотим задать пользовательский `prefix` при подключении `APIRouter`, чтобы все его *операции пути* начинались с `/admin`, хотим защитить его с помощью `dependencies`, которые у нас уже есть для этого проекта, и хотим включить `tags` и `responses`.
-Ð\9cÑ\8b можем пÑ\80имениÑ\82Ñ\8c вÑ\81е вÑ\8bÑ\88епеÑ\80еÑ\87иÑ\81леннÑ\8bе наÑ\81Ñ\82Ñ\80ойки, не изменÑ\8fÑ\8f наÑ\87алÑ\8cнÑ\8bй `APIRouter`. Ð\9dам вÑ\81его лиÑ\88Ñ\8c нÑ\83жно пеÑ\80едаÑ\82Ñ\8c нÑ\83жнÑ\8bе паÑ\80амеÑ\82Ñ\80Ñ\8b в `app.include_router()`.
+Ð\9cÑ\8b можем обÑ\8aÑ\8fвиÑ\82Ñ\8c вÑ\81Ñ\91 Ñ\8dÑ\82о, не изменÑ\8fÑ\8f иÑ\81Ñ\85однÑ\8bй `APIRouter`, пеÑ\80едав Ñ\8dÑ\82и паÑ\80амеÑ\82Ñ\80Ñ\8b в `app.include_router()`:
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[14:17] title["app/main.py"] *}
-Таким образом, оригинальный `APIRouter` не будет модифицирован, и мы сможем использовать файл `app/internal/admin.py` сразу в нескольких проектах организации.
+Таким образом исходный `APIRouter` не будет модифицирован, и мы сможем использовать файл `app/internal/admin.py` сразу в нескольких проектах организации.
-В результате, в нашем приложении каждый *эндпоинт* модуля `admin` будет иметь:
+В результате в нашем приложении каждая из *операций пути* из модуля `admin` будет иметь:
* Префикс `/admin`.
* Тег `admin`.
* Зависимость `get_token_header`.
* Ответ `418`. 🍵
-ÐÑ\82о бÑ\83деÑ\82 имеÑ\82Ñ\8c меÑ\81Ñ\82о иÑ\81клÑ\8eÑ\87иÑ\82елÑ\8cно длÑ\8f `APIRouter` в наÑ\88ем пÑ\80иложении, и не заÑ\82Ñ\80онеÑ\82 лÑ\8eбой дÑ\80Ñ\83гой код, иÑ\81полÑ\8cзÑ\83Ñ\8eÑ\89ий его.
+Ð\9dо Ñ\8dÑ\82о повлиÑ\8fеÑ\82 Ñ\82олÑ\8cко на Ñ\8dÑ\82оÑ\82 `APIRouter` в наÑ\88ем пÑ\80иложении, а не на лÑ\8eбой дÑ\80Ñ\83гой код, коÑ\82оÑ\80Ñ\8bй его иÑ\81полÑ\8cзÑ\83еÑ\82.
-Ð\9dапÑ\80имеÑ\80, дÑ\80Ñ\83гие пÑ\80оекÑ\82Ñ\8b, могÑ\83Ñ\82 иÑ\81полÑ\8cзоваÑ\82Ñ\8c Ñ\82оÑ\82 же Ñ\81амÑ\8bй `APIRouter` Ñ\81 дÑ\80Ñ\83гими меÑ\82одами аутентификации.
+Так Ñ\87Ñ\82о, напÑ\80имеÑ\80, дÑ\80Ñ\83гие пÑ\80оекÑ\82Ñ\8b могÑ\83Ñ\82 иÑ\81полÑ\8cзоваÑ\82Ñ\8c Ñ\82оÑ\82 же `APIRouter` Ñ\81 дÑ\80Ñ\83гим меÑ\82одом аутентификации.
-### Подключение отдельного *эндпоинта* { #include-a-path-operation }
+### Подключение *операции пути* { #include-a-path-operation }
-Ð\9cÑ\8b Ñ\82акже можем добавиÑ\82Ñ\8c *Ñ\8dндпоинÑ\82* непоÑ\81Ñ\80едÑ\81Ñ\82венно в оÑ\81новное приложение `FastAPI`.
+Ð\9cÑ\8b Ñ\82акже можем добавлÑ\8fÑ\82Ñ\8c *опеÑ\80аÑ\86ии пÑ\83Ñ\82и* напÑ\80Ñ\8fмÑ\83Ñ\8e в приложение `FastAPI`.
-Здесь мы это делаем ... просто, чтобы показать, что это возможно 🤷:
+Здесь мы делаем это... просто чтобы показать, что можем 🤷:
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[21:23] title["app/main.py"] *}
-и это будет работать корректно вместе с другими *эндпоинтами*, добавленными с помощью `app.include_router()`.
+и это будет работать корректно вместе со всеми другими *операциями пути*, добавленными через `app.include_router()`.
-/// info | СложнÑ\8bе технические детали
+/// info | Ð\9eÑ\87енÑ\8c технические детали
-**Примечание**: это сложная техническая деталь, которую, скорее всего, **вы можете пропустить**.
+**Примечание**: это очень техническая деталь, которую, вероятно, можно **просто пропустить**.
---
-Маршрутизаторы (`APIRouter`) не "монтируются" по-отдельности и не изолируются от остального приложения.
+`APIRouter` не «монтируются», они не изолированы от остального приложения.
-Это происходит потому, что нужно включить их *эндпоинты* в OpenAPI схему и в интерфейс пользователя.
+Это потому, что мы хотим включить их *операции пути* в OpenAPI-схему и пользовательские интерфейсы.
-Ð\92 Ñ\81илÑ\83 Ñ\82ого, Ñ\87Ñ\82о мÑ\8b не можем иÑ\85 изолиÑ\80оваÑ\82Ñ\8c и "пÑ\80имонÑ\82иÑ\80оваÑ\82Ñ\8c" незавиÑ\81имо оÑ\82 оÑ\81Ñ\82алÑ\8cнÑ\8bÑ\85, *Ñ\8dндпоинÑ\82Ñ\8b* клониÑ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f (пеÑ\80еÑ\81оздаÑ\8eÑ\82Ñ\81Ñ\8f) и не подключаются напрямую.
+Так как мÑ\8b не можем пÑ\80оÑ\81Ñ\82о изолиÑ\80оваÑ\82Ñ\8c иÑ\85 и «Ñ\81монÑ\82иÑ\80оваÑ\82Ñ\8c» незавиÑ\81имо оÑ\82 оÑ\81Ñ\82алÑ\8cного, *опеÑ\80аÑ\86ии пÑ\83Ñ\82и* «клониÑ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f» (пеÑ\80еÑ\81оздаÑ\8eÑ\82Ñ\81Ñ\8f), а не включаются напрямую.
///
Откройте документацию по адресу <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
-Вы увидите автоматическую API документацию. Она включает в себя маршруты из суб-модулей, используя верные маршруты, префиксы и теги:
+Вы увидите автоматическую документацию API, включая пути из всех подмодулей, с использованием корректных путей (и префиксов) и корректных тегов:
<img src="/img/tutorial/bigger-applications/image01.png">
-## Подключение существующего маршрута через новый префикс (`prefix`) { #include-the-same-router-multiple-times-with-different-prefix }
+## Подключение одного и того же маршрутизатора несколько раз с разными `prefix` { #include-the-same-router-multiple-times-with-different-prefix }
-Вы можете использовать `.include_router()` несколько раз с одним и тем же маршрутом, применив различные префиксы.
+Вы можете использовать `.include_router()` несколько раз с *одним и тем же* маршрутизатором, используя разные префиксы.
-Это может быть полезным, если нужно предоставить доступ к одному и тому же API через различные префиксы, например, `/api/v1` и `/api/latest`.
+Это может быть полезно, например, чтобы предоставить доступ к одному и тому же API с разными префиксами, например `/api/v1` и `/api/latest`.
-Это продвинутый способ, который вам может и не пригодится. Мы приводим его на случай, если вдруг вам это понадобится.
+Это продвинутое использование, которое вам может и не понадобиться, но оно есть на случай, если понадобится.
-## Ð\92клÑ\8eÑ\87ение одного маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80а (`APIRouter`) в дÑ\80Ñ\83гой { #include-an-apirouter-in-another }
+## Ð\9fодклÑ\8eÑ\87ение `APIRouter` в дÑ\80Ñ\83гой `APIRouter` { #include-an-apirouter-in-another }
-ТоÑ\87но Ñ\82ак же, как вÑ\8b вклÑ\8eÑ\87аеÑ\82е `APIRouter` в пÑ\80иложение `FastAPI`, вÑ\8b можеÑ\82е вклÑ\8eÑ\87иÑ\82Ñ\8c `APIRouter` в дÑ\80Ñ\83гой `APIRouter`:
+ТоÑ\87но Ñ\82ак же, как вÑ\8b можеÑ\82е подклÑ\8eÑ\87иÑ\82Ñ\8c `APIRouter` к пÑ\80иложениÑ\8e `FastAPI`, вÑ\8b можеÑ\82е подклÑ\8eÑ\87иÑ\82Ñ\8c `APIRouter` к дÑ\80Ñ\83гомÑ\83 `APIRouter`, иÑ\81полÑ\8cзÑ\83Ñ\8f:
```Python
router.include_router(other_router)
```
-УдоÑ\81Ñ\82овеÑ\80Ñ\8cÑ\82еÑ\81Ñ\8c, Ñ\87Ñ\82о вÑ\8b Ñ\81делали Ñ\8dÑ\82о до Ñ\82ого, как подклÑ\8eÑ\87иÑ\82Ñ\8c маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80 (`router`) к ваÑ\88емÑ\83 `FastAPI` пÑ\80иложениÑ\8e, и *Ñ\8dндпоинÑ\82Ñ\8b* маÑ\80Ñ\88Ñ\80Ñ\83Ñ\82изаÑ\82оÑ\80а `other_router` бÑ\8bли Ñ\82акже подключены.
+УбедиÑ\82еÑ\81Ñ\8c, Ñ\87Ñ\82о вÑ\8b Ñ\81делали Ñ\8dÑ\82о до подклÑ\8eÑ\87ениÑ\8f `router` к пÑ\80иложениÑ\8e `FastAPI`, Ñ\87Ñ\82обÑ\8b *опеÑ\80аÑ\86ии пÑ\83Ñ\82и* из `other_router` Ñ\82акже бÑ\8bли подключены.
## Обновление с заменой при помощи `PUT` { #update-replacing-with-put }
-Ð
\94лÑ\8f полного обновлениÑ\8f Ñ\8dлеменÑ\82а можно воÑ\81полÑ\8cзоваÑ\82Ñ\8cÑ\81Ñ\8f опеÑ\80аÑ\86ией <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
+Ð
§Ñ\82обÑ\8b обновиÑ\82Ñ\8c Ñ\8dлеменÑ\82, вÑ\8b можеÑ\82е иÑ\81полÑ\8cзоваÑ\82Ñ\8c опеÑ\80аÑ\86иÑ\8e <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
Вы можете использовать `jsonable_encoder`, чтобы преобразовать входные данные в данные, которые можно сохранить как JSON (например, в NoSQL-базе данных). Например, преобразование `datetime` в `str`.
{* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
-`PUT` иÑ\81полÑ\8cзÑ\83еÑ\82Ñ\81Ñ\8f длÑ\8f полÑ\83Ñ\87ениÑ\8f даннÑ\8bÑ\85, коÑ\82оÑ\80Ñ\8bе должнÑ\8b полноÑ\81Ñ\82Ñ\8cÑ\8e замениÑ\82Ñ\8c Ñ\81Ñ\83Ñ\89еÑ\81Ñ\82вÑ\83Ñ\8eÑ\89ие даннÑ\8bе.
+`PUT` используется для получения данных, которые должны заменить существующие данные.
### Предупреждение о замене { #warning-about-replacing }
поскольку оно не включает уже сохраненный атрибут `"tax": 20.2`, входная модель примет значение по умолчанию `"tax": 10.5`.
-И данные будут сохранены с этим "новым" `tax`, равным `10,5`.
+И данные будут сохранены с этим «новым» `tax`, равным `10.5`.
## Частичное обновление с помощью `PATCH` { #partial-updates-with-patch }
-Также можно использовать <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> операцию для *частичного* обновления данных.
+Также можно использовать операцию <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> для *частичного* обновления данных.
Это означает, что можно передавать только те данные, которые необходимо обновить, оставляя остальные нетронутыми.
### Использование параметра `exclude_unset` в Pydantic { #using-pydantics-exclude-unset-parameter }
-Ð\95Ñ\81ли необÑ\85одимо вÑ\8bполниÑ\82Ñ\8c Ñ\87аÑ\81Ñ\82иÑ\87ное обновление, Ñ\82о оÑ\87енÑ\8c полезно иÑ\81полÑ\8cзоваÑ\82Ñ\8c паÑ\80амеÑ\82Ñ\80 `exclude_unset` в меÑ\82оде `.model_dump()` модели Pydantic.
+Ð\95Ñ\81ли вÑ\8b Ñ\85оÑ\82иÑ\82е полÑ\83Ñ\87аÑ\82Ñ\8c Ñ\87аÑ\81Ñ\82иÑ\87нÑ\8bе обновлениÑ\8f, оÑ\87енÑ\8c полезно иÑ\81полÑ\8cзоваÑ\82Ñ\8c паÑ\80амеÑ\82Ñ\80 `exclude_unset` в `.model_dump()` модели Pydantic.
Например, `item.model_dump(exclude_unset=True)`.
-/// info | Информация
+В результате будет сгенерирован `dict`, содержащий только те данные, которые были заданы при создании модели `item`, без учета значений по умолчанию.
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он помечен как устаревший (но все еще поддерживается) и переименован в `.model_dump()`.
-
-Примеры здесь используют `.dict()` для совместимости с Pydantic v1, но если вы можете использовать Pydantic v2, лучше используйте `.model_dump()`.
-
-///
-
-В результате будет сгенерирован словарь, содержащий только те данные, которые были заданы при создании модели `item`, без учета значений по умолчанию. Затем вы можете использовать это для создания словаря только с теми данными, которые были установлены (отправлены в запросе), опуская значения по умолчанию:
+Затем вы можете использовать это для создания `dict` только с теми данными, которые были установлены (отправлены в запросе), опуская значения по умолчанию:
{* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
Теперь можно создать копию существующей модели, используя `.model_copy()`, и передать параметр `update` с `dict`, содержащим данные для обновления.
-/// info | Информация
-
-В Pydantic v1 метод назывался `.copy()`, в Pydantic v2 он помечен как устаревший (но все еще поддерживается) и переименован в `.model_copy()`.
-
-Примеры здесь используют `.copy()` для совместимости с Pydantic v1, но если вы можете использовать Pydantic v2, лучше используйте `.model_copy()`.
-
-///
-
Например, `stored_item_model.model_copy(update=update_data)`:
{* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
* (Опционально) использовать `PATCH` вместо `PUT`.
* Извлечь сохранённые данные.
-* Поместить эти данные в Pydantic модель.
+* Поместить эти данные в Pydantic-модель.
* Сгенерировать `dict` без значений по умолчанию из входной модели (с использованием `exclude_unset`).
- * Таким образом, можно обновлять только те значения, которые действительно установлены пользователем, вместо того чтобы переопределять значения, уже сохраненные в модели по умолчанию.
+ * Таким образом, можно обновлять только те значения, которые действительно установлены пользователем, вместо того чтобы переопределять уже сохраненные значения значениями по умолчанию из вашей модели.
* Создать копию хранимой модели, обновив ее атрибуты полученными частичными обновлениями (с помощью параметра `update`).
* Преобразовать скопированную модель в то, что может быть сохранено в вашей БД (например, с помощью `jsonable_encoder`).
* Это сравнимо с повторным использованием метода модели `.model_dump()`, но при этом происходит проверка (и преобразование) значений в типы данных, которые могут быть преобразованы в JSON, например, `datetime` в `str`.
/// tip | Подсказка
-Ðту же технику можно использовать и для операции HTTP `PUT`.
+Ð\9dа Ñ\81амом деле Ñ\8dту же технику можно использовать и для операции HTTP `PUT`.
Но в приведенном примере используется `PATCH`, поскольку он был создан именно для таких случаев использования.
{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
+
Так же, как при объявлении параметров запроса: когда атрибут модели имеет значение по умолчанию, он не обязателен. Иначе он обязателен. Используйте `None`, чтобы сделать его просто необязательным.
-Например, модель выше описывает такой JSON "объект" (или Python `dict`):
+Например, модель выше описывает такой JSON "`object`" (или Python `dict`):
```JSON
{
}
```
-...так как `description` и `tax` являются необязательными (со значением по умолчанию `None`), такой JSON "объект" тоже будет корректным:
+...так как `description` и `tax` являются необязательными (со значением по умолчанию `None`), такой JSON "`object`" тоже будет корректным:
```JSON
{
* Передаст полученные данные в параметр `item`.
* Поскольку внутри функции вы объявили его с типом `Item`, у вас будет поддержка со стороны редактора кода (автозавершение и т. п.) для всех атрибутов и их типов.
* Сгенерирует определения <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> для вашей модели; вы можете использовать их и в других местах, если это имеет смысл для вашего проекта.
-* Эти схемы будут частью сгенерированной схемы OpenAPI и будут использоваться автоматической документацией <abbr title="User Interfaces – Пользовательские интерфейсы">UIs</abbr>.
+* Эти схемы будут частью сгенерированной схемы OpenAPI и будут использоваться автоматической документацией <abbr title="User Interfaces - Пользовательские интерфейсы">UIs</abbr>.
## Автоматическая документация { #automatic-docs }
{* ../../docs_src/body/tutorial002_py310.py *}
-/// info | Информация
-
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он был помечен как устаревший (но всё ещё поддерживается) и переименован в `.model_dump()`.
-
-Примеры здесь используют `.dict()` для совместимости с Pydantic v1, но если вы можете использовать Pydantic v2, используйте `.model_dump()`.
-
-///
-
## Тело запроса + параметры пути { #request-body-path-parameters }
Вы можете одновременно объявить параметры пути и тело запроса.
{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
+
## Тело запроса + параметры пути + параметры запроса { #request-body-path-query-parameters }
Вы также можете одновременно объявить параметры **тела**, **пути** и **запроса**.
Параметры функции будут распознаны следующим образом:
-* Если параметр также объявлен в **пути**, он будет использоваться как параметр пути.
+* Если параметр также объявлен в **пути**, он будет использоваться как path-параметр.
* Если параметр имеет **скалярный тип** (например, `int`, `float`, `str`, `bool` и т. п.), он будет интерпретирован как параметр **запроса**.
* Если параметр объявлен как тип **модели Pydantic**, он будет интерпретирован как **тело** запроса.
FastAPI понимает, что значение `q` не является обязательным из-за значения по умолчанию `= None`.
-Аннотации типов `str | None` (Python 3.10+) или `Union[str, None]` (Python 3.9+) не используются FastAPI для определения обязательности; он узнает, что параметр не обязателен, потому что у него есть значение по умолчанию `= None`.
+Аннотации типов `str | None` (Python 3.10+) или `Union` в `Union[str, None]` (Python 3.9+) не используются FastAPI для определения обязательности; он узнает, что параметр не обязателен, потому что у него есть значение по умолчанию `= None`.
Но добавление аннотаций типов позволит вашему редактору кода лучше вас поддерживать и обнаруживать ошибки.
## Без Pydantic { #without-pydantic }
-Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры **Body**. См. раздел документации [Тело — Несколько параметров: Единичные значения в теле](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры **Body**. См. раздел документации [Тело запроса - Несколько параметров: Единичные значения в теле](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
{* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
-/// info | Информация
+### Про `**user_in.model_dump()` { #about-user-in-model-dump }
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он помечен как устаревший (но всё ещё поддерживается) и переименован в `.model_dump()`.
+#### `.model_dump()` из Pydantic { #pydantics-model-dump }
-В примерах здесь используется `.dict()` для совместимости с Pydantic v1, но если вы используете Pydantic v2, следует использовать `.model_dump()`.
+`user_in` — это Pydantic-модель класса `UserIn`.
-///
-
-### Про `**user_in.dict()` { #about-user-in-dict }
-
-#### `.dict()` из Pydantic { #pydantics-dict }
-
-`user_in` - это Pydantic-модель класса `UserIn`.
-
-У Pydantic-моделей есть метод `.dict()`, который возвращает `dict` с данными модели.
+У Pydantic-моделей есть метод `.model_dump()`, который возвращает `dict` с данными модели.
Поэтому, если мы создадим Pydantic-объект `user_in` таким способом:
и затем вызовем:
```Python
-user_dict = user_in.dict()
+user_dict = user_in.model_dump()
```
-Ñ\82о Ñ\82епеÑ\80Ñ\8c Ñ\83 наÑ\81 еÑ\81Ñ\82Ñ\8c `dict` Ñ\81 даннÑ\8bми модели в пеÑ\80еменной `user_dict` (Ñ\8dÑ\82о `dict` вмеÑ\81Ñ\82о обÑ\8aекÑ\82а Pydantic-модели).
+то теперь у нас есть `dict` с данными в переменной `user_dict` (это `dict` вместо объекта Pydantic-модели).
И если мы вызовем:
print(user_dict)
```
-мÑ\8b можем полÑ\83Ñ\87иÑ\82Ñ\8c `dict` Ñ\81 Ñ\82акими даннÑ\8bми:
+мÑ\8b полÑ\83Ñ\87им Python `dict` Ñ\81:
```Python
{
#### Распаковка `dict` { #unpacking-a-dict }
-Если мы возьмём `dict` наподобие `user_dict` и передадим его в функцию (или класс), используя `**user_dict`, Python распакует его. Он передаст ключи и значения `user_dict` напрямую как аргументы типа ключ-значение.
+Если мы возьмём `dict` наподобие `user_dict` и передадим его в функцию (или класс), используя `**user_dict`, Python его "распакует". Он передаст ключи и значения `user_dict` напрямую как аргументы типа ключ-значение.
Поэтому, продолжая описанный выше пример с `user_dict`, написание такого кода:
UserInDB(**user_dict)
```
-Ð\91Ñ\83деÑ\82 Ñ\80абоÑ\82аÑ\82Ñ\8c Ñ\82ак же, как пÑ\80имеÑ\80но Ñ\82акой код:
+бÑ\83деÑ\82 Ñ\8dквиваленÑ\82но:
```Python
UserInDB(
)
```
-Ð\98ли, еÑ\81ли длÑ\8f болÑ\8cÑ\88ей Ñ\82оÑ\87ноÑ\81Ñ\82и мÑ\8b напÑ\80Ñ\8fмÑ\83Ñ\8e иÑ\81полÑ\8cзÑ\83ем `user_dict` Ñ\81 лÑ\8eбÑ\8bм поÑ\82енÑ\86иалÑ\8cнÑ\8bм Ñ\81одеÑ\80жимÑ\8bм, Ñ\82о Ñ\8dÑ\82оÑ\82 пÑ\80имеÑ\80 бÑ\83деÑ\82 вÑ\8bглÑ\8fдеÑ\82Ñ\8c Ñ\82ак:
+Ð\98ли, более Ñ\82оÑ\87но, еÑ\81ли иÑ\81полÑ\8cзоваÑ\82Ñ\8c `user_dict` напÑ\80Ñ\8fмÑ\83Ñ\8e, Ñ\81 лÑ\8eбÑ\8bм Ñ\81одеÑ\80жимÑ\8bм, коÑ\82оÑ\80ое он можеÑ\82 имеÑ\82Ñ\8c в бÑ\83дÑ\83Ñ\89ем:
```Python
UserInDB(
)
```
-#### Pydantic-модель из содержимого другой модели { #a-pydantic-model-from-the-contents-of-another }
+#### Pydantic-модель из содержимого другой { #a-pydantic-model-from-the-contents-of-another }
-Как в примере выше мы получили `user_dict` из `user_in.dict()`, этот код:
+Как в примере выше мы получили `user_dict` из `user_in.model_dump()`, этот код:
```Python
-user_dict = user_in.dict()
+user_dict = user_in.model_dump()
UserInDB(**user_dict)
```
будет равнозначен такому:
```Python
-UserInDB(**user_in.dict())
+UserInDB(**user_in.model_dump())
```
-...потому что `user_in.dict()` - это `dict`, и затем мы указываем, чтобы Python его "распаковал", когда передаём его в `UserInDB` и ставим перед ним `**`.
+...потому что `user_in.model_dump()` — это `dict`, и затем мы указываем, чтобы Python его "распаковал", когда передаём его в `UserInDB` с префиксом `**`.
Таким образом мы получаем Pydantic-модель на основе данных из другой Pydantic-модели.
И затем, если мы добавим дополнительный именованный аргумент `hashed_password=hashed_password` как здесь:
```Python
-UserInDB(**user_in.dict(), hashed_password=hashed_password)
+UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
```
-... то мы получим что-то подобное:
+...то в итоге получится что-то подобное:
```Python
UserInDB(
/// warning | Предупреждение
-Вспомогательные функции `fake_password_hasher` и `fake_save_user` используются только для демонстрации возможного потока данных и, конечно, не обеспечивают настоящую безопасность.
+Вспомогательные дополнительные функции `fake_password_hasher` и `fake_save_user` используются только для демонстрации возможного потока данных и, конечно, не обеспечивают настоящую безопасность.
///
## Сократите дублирование { #reduce-duplication }
-Сокращение дублирования кода - это одна из главных идей **FastAPI**.
+Сокращение дублирования кода — это одна из главных идей **FastAPI**.
Поскольку дублирование кода повышает риск появления багов, проблем с безопасностью, проблем десинхронизации кода (когда вы обновляете код в одном месте, но не обновляете в другом), и т.д.
## `Union` или `anyOf` { #union-or-anyof }
-Ð\92Ñ\8b можеÑ\82е опÑ\80еделиÑ\82Ñ\8c оÑ\82веÑ\82 как `Union` из двÑ\83Ñ\85 или более Ñ\82ипов. ÐÑ\82о ознаÑ\87аеÑ\82, Ñ\87Ñ\82о оÑ\82веÑ\82 должен Ñ\81ооÑ\82веÑ\82Ñ\81Ñ\82воваÑ\82Ñ\8c одномÑ\83 из них.
+Ð\92Ñ\8b можеÑ\82е обÑ\8aÑ\8fвиÑ\82Ñ\8c HTTP-оÑ\82веÑ\82 как `Union` из двÑ\83Ñ\85 или более Ñ\82ипов. ÐÑ\82о ознаÑ\87аеÑ\82, Ñ\87Ñ\82о HTTP-оÑ\82веÑ\82 можеÑ\82 бÑ\8bÑ\82Ñ\8c лÑ\8eбÑ\8bм из них.
Он будет определён в OpenAPI как `anyOf`.
/// note | Примечание
-При объявлении <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a>, сначала указывайте наиболее детальные типы, затем менее детальные. В примере ниже более детальный `PlaneItem` стоит перед `CarItem` в `Union[PlaneItem, CarItem]`.
+При объявлении <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a> сначала указывайте наиболее специфичный тип, затем менее специфичный. В примере ниже более специфичный `PlaneItem` стоит перед `CarItem` в `Union[PlaneItem, CarItem]`.
///
some_variable: PlaneItem | CarItem
```
-Ð\9dо еÑ\81ли мÑ\8b помеÑ\89аем его в `response_model=PlaneItem | CarItem` мы получим ошибку, потому что Python попытается произвести **некорректную операцию** между `PlaneItem` и `CarItem` вместо того, чтобы интерпретировать это как аннотацию типа.
+Ð\9dо еÑ\81ли мÑ\8b помеÑ\81Ñ\82им Ñ\8dÑ\82о в пÑ\80иÑ\81ваивание `response_model=PlaneItem | CarItem`, мы получим ошибку, потому что Python попытается произвести **некорректную операцию** между `PlaneItem` и `CarItem` вместо того, чтобы интерпретировать это как аннотацию типа.
## Список моделей { #list-of-models }
-Таким же обÑ\80азом вÑ\8b можеÑ\82е опÑ\80еделÑ\8fÑ\82Ñ\8c оÑ\82веÑ\82Ñ\8b как списки объектов.
+Таким же обÑ\80азом вÑ\8b можеÑ\82е обÑ\8aÑ\8fвлÑ\8fÑ\82Ñ\8c HTTP-оÑ\82веÑ\82Ñ\8b, возвÑ\80аÑ\89аÑ\8eÑ\89ие списки объектов.
-Для этого используйте `typing.List` из стандартной библиотеки Python (или просто `list` в Python 3.9 и выше):
+Для этого используйте стандартный `typing.List` в Python (или просто `list` в Python 3.9 и выше):
{* ../../docs_src/extra_models/tutorial004_py39.py hl[18] *}
## Ответ с произвольным `dict` { #response-with-arbitrary-dict }
-Ð\92Ñ\8b Ñ\82акже можеÑ\82е опÑ\80еделиÑ\82Ñ\8c оÑ\82веÑ\82, иÑ\81полÑ\8cзÑ\83Ñ\8f пÑ\80оизволÑ\8cнÑ\8bй одноÑ\83Ñ\80овневÑ\8bй `dict` и опÑ\80еделÑ\8fÑ\8f Ñ\82олÑ\8cко Ñ\82ипÑ\8b клÑ\8eÑ\87ей и знаÑ\87ений без иÑ\81полÑ\8cзованиÑ\8f Pydantic-моделей.
+Ð\92Ñ\8b Ñ\82акже можеÑ\82е обÑ\8aÑ\8fвиÑ\82Ñ\8c HTTP-оÑ\82веÑ\82, иÑ\81полÑ\8cзÑ\83Ñ\8f обÑ\8bÑ\87нÑ\8bй пÑ\80оизволÑ\8cнÑ\8bй `dict`, обÑ\8aÑ\8fвив Ñ\82олÑ\8cко Ñ\82ип клÑ\8eÑ\87ей и знаÑ\87ений, без иÑ\81полÑ\8cзованиÑ\8f Pydantic-модели.
Это полезно, если вы заранее не знаете корректных названий полей/атрибутов (которые будут нужны при использовании Pydantic-модели).
## Резюме { #recap }
-Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е неÑ\81колÑ\8cко Pydantic-моделей и Ñ\81вободно пÑ\80именÑ\8fйÑ\82е наÑ\81ледование длÑ\8f каждой из ниÑ\85.
+Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е неÑ\81колÑ\8cко Pydantic-моделей и Ñ\81вободно пÑ\80именÑ\8fйÑ\82е наÑ\81ледование длÑ\8f каждого Ñ\81лÑ\83Ñ\87аÑ\8f.
-Вам не обязательно иметь единственную модель данных для каждой сущности, если эта сущность должна иметь возможность быть в разных "состояниях". Как в случае с "сущностью" пользователя, у которого есть состояния с полями `password`, `password_hash` и без пароля.
+Вам не обязательно иметь единственную модель данных для каждой сущности, если эта сущность должна иметь возможность быть в разных "состояниях". Как в случае с "сущностью" пользователя, у которого есть состояние, включающее `password`, `password_hash` и отсутствие пароля.
Query-параметр `q` имеет тип `str | None`, это означает, что он имеет тип `str`, но также может быть `None`. Значение по умолчанию действительно `None`, поэтому FastAPI будет знать, что он не обязателен.
-/// note | ТеÑ\85ниÑ\87еÑ\81кие деÑ\82али
+/// note | Ð\9fÑ\80имеÑ\87ание
FastAPI поймёт, что значение `q` не обязательно, из‑за значения по умолчанию `= None`.
**Значение по умолчанию** у **параметра функции** — это **настоящее значение по умолчанию**, что более интуитивно для Python. 😌
-Вы можете **вызвать** эту же функцию в **других местах** без FastAPI, и она будет **работать как ожидается**. Если есть **обязательный** параметр (без значения по умолчанию), ваш **редактор кода** сообщит об ошибке, **Python** тоже пожалуется, если вы запустите её без передачи обязательного параметра.
+Вы можете **вызвать** эту же функцию в **других местах** без FastAPI, и она будет **работать как ожидается**. Если есть **обязательный** параметр (без значения по умолчанию), ваш **редактор** сообщит об ошибке, **Python** тоже пожалуется, если вы запустите её без передачи обязательного параметра.
Если вы не используете `Annotated`, а применяете **(устаревший) стиль со значением по умолчанию**, то при вызове этой функции без FastAPI в **других местах** вам нужно **помнить** о том, что надо передать аргументы, чтобы всё работало корректно, иначе значения будут не такими, как вы ожидаете (например, вместо `str` будет `QueryInfo` или что-то подобное). И ни редактор, ни Python не будут ругаться при самом вызове функции — ошибка проявится лишь при операциях внутри.
## Регулярные выражения { #add-regular-expressions }
-Вы можете определить <abbr title="Регулярное выражение (regex, regexp) — это последовательность символов, задающая шаблон поиска для строк.">регулярное выражение</abbr> `pattern`, которому должен соответствовать параметр:
+Вы можете определить <abbr title="Регулярное выражение (regex, regexp) - это последовательность символов, задающая шаблон поиска для строк.">регулярное выражение</abbr> `pattern`, которому должен соответствовать параметр:
{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
Теперь вы знаете, что когда они понадобятся, вы сможете использовать их в **FastAPI**.
-### `regex` из Pydantic v1 вместо `pattern` { #pydantic-v1-regex-instead-of-pattern }
-
-До Pydantic версии 2 и до FastAPI 0.100.0 этот параметр назывался `regex`, а не `pattern`, но сейчас он устарел.
-
-Вы всё ещё можете встретить такой код:
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/query_params_str_validations/tutorial004_regex_an_py310.py hl[11] *}
-
-////
-
-Имейте в виду, что это устарело, и код следует обновить на использование нового параметра `pattern`. 🤓
-
## Значения по умолчанию { #default-values }
Конечно, можно использовать и другие значения по умолчанию, не только `None`.
http://localhost:8000/items/?q=foo&q=bar
```
-вы получите множественные значения query-параметра `q` (`foo` и `bar`) в виде Python-`list` внутри вашей *функции обработки пути*, в *параметре функции* `q`.
+вы получите множественные значения *query-параметров* `q` (`foo` и `bar`) в виде Python-`list` внутри вашей *функции-обработчика пути*, в *параметре функции* `q`.
Таким образом, ответ на этот URL будет:
{* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
-/// note | ТеÑ\85ниÑ\87еÑ\81кие деÑ\82али
+/// note | Ð\9fÑ\80имеÑ\87ание
Имейте в виду, что в этом случае FastAPI не будет проверять содержимое списка.
Эта информация будет включена в сгенерированную OpenAPI-схему и использована интерфейсами документации и внешними инструментами.
-/// note | ТеÑ\85ниÑ\87еÑ\81кие деÑ\82али
+/// note | Ð\9fÑ\80имеÑ\87ание
Помните, что разные инструменты могут иметь разный уровень поддержки OpenAPI.
///
-Например, эта кастомная проверка убеждается, что ID элемента начинается с `isbn-` для номера книги <abbr title="ISBN означает International Standard Book Number – Международный стандартный книжный номер">ISBN</abbr> или с `imdb-` для ID URL фильма на <abbr title="IMDB (Internet Movie Database) — веб‑сайт с информацией о фильмах">IMDB</abbr>:
+Например, эта кастомная проверка убеждается, что ID элемента начинается с `isbn-` для номера книги <abbr title="ISBN означает International Standard Book Number - Международный стандартный книжный номер">ISBN</abbr> или с `imdb-` для ID URL фильма на <abbr title="IMDB (Internet Movie Database) - веб‑сайт с информацией о фильмах">IMDB</abbr>:
{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
Затем с `random.choice()` можно получить **случайное значение** из списка — то есть кортеж вида `(id, name)`. Это будет что‑то вроде `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
-После этого мы **распаковываем** эти два значения кортежа в переменные `id` и `name`.
+После этого мы **присваиваем эти два значения** кортежа переменным `id` и `name`.
Так что, если пользователь не передал ID элемента, он всё равно получит случайную рекомендацию.
{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
-FastAPI будет использовать этот тип ответа для:
+FastAPI будет использовать этот возвращаемый тип, чтобы:
-* **Ð\92алидаÑ\86ии** возвÑ\80аÑ\89аемÑ\8bÑ\85 даннÑ\8bÑ\85.
- * Если данные невалидны (например, отсутствует поле), это означает, что код *вашего* приложения работает некорректно и возвращает не то, что должен. В таком случае будет возвращена ошибка сервера вместо неправильных данных. Так вы и ваши клиенты можете быть уверены, что получите ожидаемые данные и ожидаемую структуру.
-* Ð\94обавлениÑ\8f **JSON Schema** для ответа в OpenAPI *операции пути*.
+* **Ð\92алидиÑ\80оваÑ\82Ñ\8c** возвÑ\80аÑ\89аемÑ\8bе даннÑ\8bе.
+ * Если данные невалидны (например, отсутствует поле), это означает, что код *вашего* приложения работает некорректно и возвращает не то, что должен. В таком случае будет возвращена ошибка сервера вместо неправильных данных. Так вы и ваши клиенты можете быть уверены, что получите ожидаемые данные и ожидаемую структуру данных.
+* Ð\94обавиÑ\82Ñ\8c **JSON Schema** для ответа в OpenAPI *операции пути*.
* Это будет использовано **автоматической документацией**.
* Это также будет использовано инструментами автоматической генерации клиентского кода.
Бывают случаи, когда вам нужно или хочется возвращать данные, которые не в точности соответствуют объявленному типу.
-Например, вы можете хотеть **возвращать словарь (dict)** или объект из базы данных, но **объявить его как Pydantic-модель**. Тогда Pydantic-модель выполнит документирование данных, валидацию и т.п. для объекта, который вы вернули (например, словаря или объекта из базы данных).
+Например, вы можете хотеть **возвращать словарь** или объект из базы данных, но **объявить его как Pydantic-модель**. Тогда Pydantic-модель выполнит документирование данных, валидацию и т.п. для объекта, который вы вернули (например, словаря или объекта из базы данных).
Если вы добавите аннотацию возвращаемого типа, инструменты и редакторы кода начнут жаловаться (и будут правы), что функция возвращает тип (например, dict), отличный от объявленного (например, Pydantic-модель).
`response_model` принимает тот же тип, что вы бы объявили для поля Pydantic-модели, то есть это может быть одна Pydantic-модель, а может быть, например, `list` Pydantic-моделей, как `List[Item]`.
-FastAPI будет использовать `response_model` для документации, валидации и т. п., а также для **конвертации и фильтрации выходных данных** к объявленному типу.
+FastAPI будет использовать этот `response_model` для документирования, валидации данных и т.п., а также для **конвертации и фильтрации выходных данных** к объявленному типу.
/// tip | Совет
-Если у вас в редакторе кода, mypy и т. п. включены строгие проверки типов, вы можете объявить возвращаемый тип функции как `Any`.
+Если у вас в редакторе кода, mypy и т.п. включены строгие проверки типов, вы можете объявить возвращаемый тип функции как `Any`.
-Так вÑ\8b Ñ\81ообÑ\89иÑ\82е Ñ\80едакÑ\82оÑ\80Ñ\83, Ñ\87Ñ\82о намеÑ\80енно возвÑ\80аÑ\89аеÑ\82е Ñ\87Ñ\82о Ñ\83годно. Ð\9dо FastAPI вÑ\81Ñ\91 Ñ\80авно вÑ\8bполниÑ\82 докÑ\83менÑ\82аÑ\86иÑ\8e даннÑ\8bÑ\85, валидаÑ\86иÑ\8e, Ñ\84илÑ\8cÑ\82Ñ\80аÑ\86иÑ\8e и т.д. с помощью `response_model`.
+Так вÑ\8b Ñ\81ообÑ\89иÑ\82е Ñ\80едакÑ\82оÑ\80Ñ\83, Ñ\87Ñ\82о намеÑ\80енно возвÑ\80аÑ\89аеÑ\82е Ñ\87Ñ\82о Ñ\83годно. Ð\9dо FastAPI вÑ\81Ñ\91 Ñ\80авно вÑ\8bполниÑ\82 докÑ\83менÑ\82иÑ\80ование, валидаÑ\86иÑ\8e, Ñ\84илÑ\8cÑ\82Ñ\80аÑ\86иÑ\8e даннÑ\8bÑ\85 и т.д. с помощью `response_model`.
///
Если вы объявите и возвращаемый тип, и `response_model`, приоритет будет у `response_model`, именно его использует FastAPI.
-Так вы можете добавить корректные аннотации типов к своим функциям, даже если фактически возвращаете тип, отличный от модели ответа, чтобы ими пользовались редактор и инструменты вроде mypy. И при этом FastAPI продолжит выполнять валидацию данных, документацию и т.д. с использованием `response_model`.
+Так вÑ\8b можеÑ\82е добавиÑ\82Ñ\8c коÑ\80Ñ\80екÑ\82нÑ\8bе анноÑ\82аÑ\86ии Ñ\82ипов к Ñ\81воим Ñ\84Ñ\83нкÑ\86иÑ\8fм, даже еÑ\81ли Ñ\84акÑ\82иÑ\87еÑ\81ки возвÑ\80аÑ\89аеÑ\82е Ñ\82ип, оÑ\82лиÑ\87нÑ\8bй оÑ\82 модели оÑ\82веÑ\82а, Ñ\87Ñ\82обÑ\8b ими полÑ\8cзовалиÑ\81Ñ\8c Ñ\80едакÑ\82оÑ\80 кода и инÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\8b вÑ\80оде mypy. Ð\98 пÑ\80и Ñ\8dÑ\82ом FastAPI пÑ\80одолжиÑ\82 вÑ\8bполнÑ\8fÑ\82Ñ\8c валидаÑ\86иÑ\8e даннÑ\8bÑ\85, докÑ\83менÑ\82аÑ\86иÑ\8e и Ñ\82.д. Ñ\81 иÑ\81полÑ\8cзованием `response_model`.
Вы также можете указать `response_model=None`, чтобы отключить создание модели ответа для данной *операции пути*. Это может понадобиться, если вы добавляете аннотации типов для вещей, не являющихся валидными полями Pydantic. Пример вы увидите ниже.
Чтобы использовать `EmailStr`, сначала установите <a href="https://github.com/JoshData/python-email-validator" class="external-link" target="_blank">`email-validator`</a>.
-СоздайÑ\82е [виÑ\80Ñ\82Ñ\83алÑ\8cное окÑ\80Ñ\83жение](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивиÑ\80Ñ\83йÑ\82е его и затем установите пакет, например:
+УбедиÑ\82еÑ\81Ñ\8c, Ñ\87Ñ\82о вÑ\8b Ñ\81оздали [виÑ\80Ñ\82Ñ\83алÑ\8cное окÑ\80Ñ\83жение](../virtual-environments.md){.internal-link target=_blank}, акÑ\82ивиÑ\80овали его, а затем установите пакет, например:
```console
$ pip install email-validator
///
-## Ð\94обавиÑ\82Ñ\8c моделÑ\8c длÑ\8f оÑ\82веÑ\82а { #add-an-output-model }
+## Ð\94обавиÑ\82Ñ\8c вÑ\8bÑ\85однÑ\83Ñ\8e моделÑ\8c { #add-an-output-model }
Вместо этого мы можем создать входную модель с паролем в открытом виде и выходную модель без него:
### `response_model` или возвращаемый тип { #response-model-or-return-type }
-В этом случае, поскольку две модели различаются, если бы мы аннотировали возвращаемый тип функции как `UserOut`, редактор и инструменты пожаловались бы, что мы возвращаем неверный тип, так как это разные классы.
+Ð\92 Ñ\8dÑ\82ом Ñ\81лÑ\83Ñ\87ае, поÑ\81колÑ\8cкÑ\83 две модели Ñ\80азлиÑ\87аÑ\8eÑ\82Ñ\81Ñ\8f, еÑ\81ли бÑ\8b мÑ\8b анноÑ\82иÑ\80овали возвÑ\80аÑ\89аемÑ\8bй Ñ\82ип Ñ\84Ñ\83нкÑ\86ии как `UserOut`, Ñ\80едакÑ\82оÑ\80 кода и инÑ\81Ñ\82Ñ\80Ñ\83менÑ\82Ñ\8b пожаловалиÑ\81Ñ\8c бÑ\8b, Ñ\87Ñ\82о мÑ\8b возвÑ\80аÑ\89аем невеÑ\80нÑ\8bй Ñ\82ип, Ñ\82ак как Ñ\8dÑ\82о Ñ\80азнÑ\8bе клаÑ\81Ñ\81Ñ\8b.
Поэтому в этом примере мы должны объявить тип ответа в параметре `response_model`.
Мы хотим, чтобы FastAPI продолжал **фильтровать** данные с помощью модели ответа. Так что, даже если функция возвращает больше данных, в ответ будут включены только поля, объявленные в модели ответа.
-В предыдущем примере, поскольку классы были разными, нам пришлось использовать параметр `response_model`. Но это также означает, что мы теряем поддержку от редактора и инструментов, проверяющих возвращаемый тип функции.
+Ð\92 пÑ\80едÑ\8bдÑ\83Ñ\89ем пÑ\80имеÑ\80е, поÑ\81колÑ\8cкÑ\83 клаÑ\81Ñ\81Ñ\8b бÑ\8bли Ñ\80азнÑ\8bми, нам пÑ\80иÑ\88лоÑ\81Ñ\8c иÑ\81полÑ\8cзоваÑ\82Ñ\8c паÑ\80амеÑ\82Ñ\80 `response_model`. Ð\9dо Ñ\8dÑ\82о Ñ\82акже ознаÑ\87аеÑ\82, Ñ\87Ñ\82о мÑ\8b Ñ\82еÑ\80Ñ\8fем поддеÑ\80жкÑ\83 оÑ\82 Ñ\80едакÑ\82оÑ\80а кода и инÑ\81Ñ\82Ñ\80Ñ\83менÑ\82ов, пÑ\80овеÑ\80Ñ\8fÑ\8eÑ\89иÑ\85 возвÑ\80аÑ\89аемÑ\8bй Ñ\82ип Ñ\84Ñ\83нкÑ\86ии.
Однако в большинстве таких случаев нам нужно лишь **отфильтровать/убрать** некоторые данные, как в этом примере.
-И в этих случаях мы можем использовать классы и наследование, чтобы воспользоваться **аннотациями типов** функций для лучшей поддержки в редакторе и инструментах и при этом получить **фильтрацию данных** от FastAPI.
+Ð\98 в Ñ\8dÑ\82иÑ\85 Ñ\81лÑ\83Ñ\87аÑ\8fÑ\85 мÑ\8b можем иÑ\81полÑ\8cзоваÑ\82Ñ\8c клаÑ\81Ñ\81Ñ\8b и наÑ\81ледование, Ñ\87Ñ\82обÑ\8b воÑ\81полÑ\8cзоваÑ\82Ñ\8cÑ\81Ñ\8f **анноÑ\82аÑ\86иÑ\8fми Ñ\82ипов** Ñ\84Ñ\83нкÑ\86ий длÑ\8f лÑ\83Ñ\87Ñ\88ей поддеÑ\80жки в Ñ\80едакÑ\82оÑ\80е кода и инÑ\81Ñ\82Ñ\80Ñ\83менÑ\82аÑ\85 и пÑ\80и Ñ\8dÑ\82ом полÑ\83Ñ\87иÑ\82Ñ\8c **Ñ\84илÑ\8cÑ\82Ñ\80аÑ\86иÑ\8e даннÑ\8bÑ\85** оÑ\82 FastAPI.
{* ../../docs_src/response_model/tutorial003_01_py310.py hl[7:10,13:14,18] *}
-Так мы получаем поддержку инструментов (редакторы, mypy) — код корректен с точки зрения типов — и одновременно получаем фильтрацию данных от FastAPI.
+Так мы получаем поддержку инструментов — редакторов кода и mypy, так как этот код корректен с точки зрения типов — и одновременно получаем фильтрацию данных от FastAPI.
Как это работает? Давайте разберёмся. 🤓
### Аннотации типов и инструменты { #type-annotations-and-tooling }
-Сначала посмотрим, как это увидят редакторы, mypy и другие инструменты.
+Сначала посмотрим, как это увидят редактор кода, mypy и другие инструменты.
-`BaseUser` Ñ\81одеÑ\80жиÑ\82 базовÑ\8bе полÑ\8f. Ð\97аÑ\82ем `UserIn` наÑ\81ледÑ\83еÑ\82Ñ\81Ñ\8f оÑ\82 `BaseUser` и добавлÑ\8fеÑ\82 поле `password`, Ñ\82о еÑ\81Ñ\82Ñ\8c он вклÑ\8eÑ\87аеÑ\82 все поля обеих моделей.
+`BaseUser` Ñ\81одеÑ\80жиÑ\82 базовÑ\8bе полÑ\8f. Ð\97аÑ\82ем `UserIn` наÑ\81ледÑ\83еÑ\82Ñ\81Ñ\8f оÑ\82 `BaseUser` и добавлÑ\8fеÑ\82 поле `password`, Ñ\82о еÑ\81Ñ\82Ñ\8c он бÑ\83деÑ\82 вклÑ\8eÑ\87аÑ\82Ñ\8c все поля обеих моделей.
Мы аннотируем возвращаемый тип функции как `BaseUser`, но фактически возвращаем экземпляр `UserIn`.
-Редактор, mypy и другие инструменты не будут возражать, потому что с точки зрения типов `UserIn` — подкласс `BaseUser`, что означает, что это *валидный* тип везде, где ожидается что-то, являющееся `BaseUser`.
+Редактор кода, mypy и другие инструменты не будут возражать, потому что с точки зрения типов `UserIn` — подкласс `BaseUser`, что означает, что это *валидный* тип везде, где ожидается что-то, являющееся `BaseUser`.
### Фильтрация данных FastAPI { #fastapi-data-filtering }
-Теперь, для FastAPI: он увидит возвращаемый тип и убедится, что то, что вы возвращаете, включает **только** поля, объявленные в этом типе.
+Теперь для FastAPI: он увидит возвращаемый тип и убедится, что то, что вы возвращаете, включает **только** поля, объявленные в этом типе.
-FastAPI делает несколько вещей внутри вместе с Pydantic, чтобы гарантировать, что те же правила наследования классов не используются для фильтрации возвращаемых данных, иначе вы могли бы вернуть гораздо больше данных, чем ожидали.
+FastAPI делает несколько вещей внутри вместе с Pydantic, чтобы гарантировать, что те же правила наследования классов не используются для фильтрации возвращаемых данных, иначе вы могли бы в итоге вернуть намного больше данных, чем ожидали.
Таким образом вы получаете лучшее из обоих миров: аннотации типов с **поддержкой инструментов** и **фильтрацию данных**.
<img src="/img/tutorial/response-model/image01.png">
-Ð\98 обе модели иÑ\81полÑ\8cзÑ\83Ñ\8eÑ\82ся в интерактивной документации API:
+Ð\98 обе модели бÑ\83дÑ\83Ñ\82 иÑ\81полÑ\8cзоваÑ\82Ñ\8cся в интерактивной документации API:
<img src="/img/tutorial/response-model/image02.png">
## Другие аннотации возвращаемых типов { #other-return-type-annotations }
-Бывают случаи, когда вы возвращаете что-то, что не является валидным полем Pydantic, и аннотируете это в функции только ради поддержки инструментов (редактор, mypy и т. д.).
+Бывают случаи, когда вы возвращаете что-то, что не является валидным полем Pydantic, и аннотируете это в функции только ради поддержки инструментов (редактор кода, mypy и т.д.).
### Возврат Response напрямую { #return-a-response-directly }
-Самый распространённый случай — [возвращать Response напрямую, как описано далее в разделах для продвинутых](../advanced/response-directly.md){.internal-link target=_blank}.
+СамÑ\8bй Ñ\80аÑ\81пÑ\80оÑ\81Ñ\82Ñ\80анÑ\91ннÑ\8bй Ñ\81лÑ\83Ñ\87ай â\80\94 [возвÑ\80аÑ\89аÑ\82Ñ\8c Response напÑ\80Ñ\8fмÑ\83Ñ\8e, как опиÑ\81ано далее в Ñ\80азделаÑ\85 докÑ\83менÑ\82аÑ\86ии длÑ\8f пÑ\80одвинÑ\83Ñ\82Ñ\8bÑ\85](../advanced/response-directly.md){.internal-link target=_blank}.
{* ../../docs_src/response_model/tutorial003_02_py39.py hl[8,10:11] *}
{* ../../docs_src/response_model/tutorial003_03_py39.py hl[8:9] *}
-Это тоже сработает, так как `RedirectResponse` — подкласс `Response`, и FastAPI автоматически обработает этот случай.
+Это тоже сработает, так как `RedirectResponse` — подкласс `Response`, и FastAPI автоматически обработает этот простой случай.
### Некорректные аннотации возвращаемых типов { #invalid-return-type-annotations }
### Отключить модель ответа { #disable-response-model }
-Ð\9fÑ\80одолжаÑ\8f пÑ\80имеÑ\80 вÑ\8bÑ\88е, вÑ\8b можеÑ\82е не Ñ\85оÑ\82еÑ\82Ñ\8c иÑ\81полÑ\8cзоваÑ\82Ñ\8c Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\83Ñ\8e валидаÑ\86иÑ\8e даннÑ\8bÑ\85, докÑ\83менÑ\82аÑ\86иÑ\8e, Ñ\84илÑ\8cÑ\82Ñ\80аÑ\86иÑ\8e и Ñ\82.д., выполняемые FastAPI.
+Ð\9fÑ\80одолжаÑ\8f пÑ\80имеÑ\80 вÑ\8bÑ\88е, вÑ\8b можеÑ\82е не Ñ\85оÑ\82еÑ\82Ñ\8c иÑ\81полÑ\8cзоваÑ\82Ñ\8c Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\8bе валидаÑ\86иÑ\8e даннÑ\8bÑ\85, докÑ\83менÑ\82иÑ\80ование, Ñ\84илÑ\8cÑ\82Ñ\80аÑ\86иÑ\8e и Ñ\82.п., выполняемые FastAPI.
-Но при этом вы можете хотеть сохранить аннотацию возвращаемого типа в функции, чтобы пользоваться поддержкой инструментов (редакторы, проверки типов вроде mypy).
+Но при этом вы можете хотеть сохранить аннотацию возвращаемого типа в функции, чтобы пользоваться поддержкой инструментов вроде редакторов кода и инструментов проверки типов (например, mypy).
В этом случае вы можете отключить генерацию модели ответа, установив `response_model=None`:
{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}
-Так FastAPI пÑ\80опÑ\83Ñ\81Ñ\82иÑ\82 генеÑ\80аÑ\86иÑ\8e модели оÑ\82веÑ\82а, и вÑ\8b Ñ\81можеÑ\82е иÑ\81полÑ\8cзоваÑ\82Ñ\8c лÑ\8eбÑ\8bе анноÑ\82аÑ\86ии возвÑ\80аÑ\89аемÑ\8bÑ\85 Ñ\82ипов, не влиÑ\8fя на ваше приложение FastAPI. 🤓
+Так FastAPI пÑ\80опÑ\83Ñ\81Ñ\82иÑ\82 генеÑ\80аÑ\86иÑ\8e модели оÑ\82веÑ\82а, и вÑ\8b Ñ\81можеÑ\82е иÑ\81полÑ\8cзоваÑ\82Ñ\8c лÑ\8eбÑ\8bе анноÑ\82аÑ\86ии возвÑ\80аÑ\89аемÑ\8bÑ\85 Ñ\82ипов, коÑ\82оÑ\80Ñ\8bе вам нÑ\83жнÑ\8b, без влиÑ\8fния на ваше приложение FastAPI. 🤓
## Параметры кодирования модели ответа { #response-model-encoding-parameters }
/// info | Информация
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он был помечен как устаревший (но всё ещё поддерживается) и переименован в `.model_dump()`.
-
-Примеры здесь используют `.dict()` для совместимости с Pydantic v1, но если вы используете Pydantic v2, применяйте `.model_dump()`.
-
-///
-
-/// info | Информация
-
-FastAPI использует метод `.dict()` у Pydantic-моделей с <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">параметром `exclude_unset`</a>, чтобы добиться такого поведения.
-
-///
-
-/// info | Информация
-
Вы также можете использовать:
* `response_model_exclude_defaults=True`
Обратите внимание, что значения по умолчанию могут быть любыми, не только `None`.
-Это может быть список (`[]`), число с плавающей точкой `10.5` и т. д.
+Это может быть список (`[]`), число с плавающей точкой `10.5` и т.д.
///
#### Использование `list` вместо `set` { #using-lists-instead-of-sets }
-Если вы забыли использовать `set` и применили `list` или `tuple`, FastAPI всё равно преобразует это в `set`, и всё будет работать корректно:
+Если вы забыли использовать `set` и применили `list` или `tuple` вместо него, FastAPI всё равно преобразует это в `set`, и всё будет работать корректно:
{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}
Вы можете объявить `examples` для модели Pydantic, которые будут добавлены в сгенерированную JSON Schema.
-//// tab | Pydantic v2
-
{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/schema_extra_example/tutorial001_pv1_py310.py hl[13:23] *}
-
-////
-
Эта дополнительная информация будет добавлена как есть в выходную **JSON Schema** этой модели и будет использоваться в документации API.
-//// tab | Pydantic v2
-
-В Pydantic версии 2 вы будете использовать атрибут `model_config`, который принимает `dict`, как описано в <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">Документации Pydantic: Конфигурация</a>.
+Вы можете использовать атрибут `model_config`, который принимает `dict`, как описано в <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">Документации Pydantic: Конфигурация</a>.
Вы можете задать `"json_schema_extra"` с `dict`, содержащим любые дополнительные данные, которые вы хотите видеть в сгенерированной JSON Schema, включая `examples`.
-////
-
-//// tab | Pydantic v1
-
-В Pydantic версии 1 вы будете использовать внутренний класс `Config` и `schema_extra`, как описано в <a href="https://docs.pydantic.dev/1.10/usage/schema/#schema-customization" class="external-link" target="_blank">Документации Pydantic: Настройка схемы</a>.
-
-Вы можете задать `schema_extra` со `dict`, содержащим любые дополнительные данные, которые вы хотите видеть в сгенерированной JSON Schema, включая `examples`.
-
-////
-
/// tip | Подсказка
Вы можете использовать тот же приём, чтобы расширить JSON Schema и добавить свою собственную дополнительную информацию.
Ключи `dict` идентифицируют каждый пример, а каждое значение — это ещё один `dict`.
-Каждый конкретный пример‑`dict` в `examples` может содержать:
+Каждый конкретный пример `dict` в `examples` может содержать:
* `summary`: Краткое описание примера.
* `description`: Подробное описание, которое может содержать текст в Markdown.
{* ../../docs_src/schema_extra_example/tutorial005_an_py310.py hl[23:49] *}
-### OpenAPI-примеры в UI документации { #openapi-examples-in-the-docs-ui }
+### OpenAPI-примеры в UI документации { #openapi-examples-in-the-docs-ui }
С `openapi_examples`, добавленным в `Body()`, страница `/docs` будет выглядеть так:
### Swagger UI и специфичные для OpenAPI `examples` { #swagger-ui-and-openapi-specific-examples }
-РанÑ\8cÑ\88е, поскольку Swagger UI не поддерживал несколько примеров JSON Schema (по состоянию на 2023-08-26), у пользователей не было способа показать несколько примеров в документации.
+ТепеÑ\80Ñ\8c, поскольку Swagger UI не поддерживал несколько примеров JSON Schema (по состоянию на 2023-08-26), у пользователей не было способа показать несколько примеров в документации.
Чтобы решить это, FastAPI `0.103.0` **добавил поддержку** объявления того же старого, **специфичного для OpenAPI**, поля `examples` с новым параметром `openapi_examples`. 🤓
projects / thirdparty / fastapi / fastapi.git / commitdiff
