Browse Source

๐Ÿ”ง Update docs setup with latest configs and plugins (#11953)

pull/11956/head
Sebastiรกn Ramรญrez 10 months ago
committed by GitHub
parent
commit
0cd844d387
No known key found for this signature in database GPG Key ID: B5690EEEBB952194
  1. 23
      .github/workflows/build-docs.yml
  2. 111
      docs/bn/docs/python-types.md
  3. 25
      docs/de/docs/advanced/additional-responses.md
  4. 40
      docs/de/docs/advanced/additional-status-codes.md
  5. 73
      docs/de/docs/advanced/advanced-dependencies.md
  6. 20
      docs/de/docs/advanced/async-tests.md
  7. 35
      docs/de/docs/advanced/behind-a-proxy.md
  8. 55
      docs/de/docs/advanced/custom-response.md
  9. 5
      docs/de/docs/advanced/dataclasses.md
  10. 25
      docs/de/docs/advanced/events.md
  11. 37
      docs/de/docs/advanced/generate-clients.md
  12. 5
      docs/de/docs/advanced/index.md
  13. 5
      docs/de/docs/advanced/middleware.md
  14. 25
      docs/de/docs/advanced/openapi-callbacks.md
  15. 10
      docs/de/docs/advanced/openapi-webhooks.md
  16. 56
      docs/de/docs/advanced/path-operation-advanced-configuration.md
  17. 10
      docs/de/docs/advanced/response-cookies.md
  18. 10
      docs/de/docs/advanced/response-directly.md
  19. 5
      docs/de/docs/advanced/response-headers.md
  20. 51
      docs/de/docs/advanced/security/http-basic-auth.md
  21. 5
      docs/de/docs/advanced/security/index.md
  22. 346
      docs/de/docs/advanced/security/oauth2-scopes.md
  23. 145
      docs/de/docs/advanced/settings.md
  24. 15
      docs/de/docs/advanced/templates.md
  25. 40
      docs/de/docs/advanced/testing-dependencies.md
  26. 5
      docs/de/docs/advanced/testing-websockets.md
  27. 10
      docs/de/docs/advanced/using-request-directly.md
  28. 58
      docs/de/docs/advanced/websockets.md
  29. 121
      docs/de/docs/alternatives.md
  30. 20
      docs/de/docs/async.md
  31. 65
      docs/de/docs/contributing.md
  32. 20
      docs/de/docs/deployment/concepts.md
  33. 50
      docs/de/docs/deployment/docker.md
  34. 15
      docs/de/docs/deployment/https.md
  35. 26
      docs/de/docs/deployment/manually.md
  36. 5
      docs/de/docs/deployment/server-workers.md
  37. 10
      docs/de/docs/deployment/versions.md
  38. 10
      docs/de/docs/external-links.md
  39. 5
      docs/de/docs/features.md
  40. 10
      docs/de/docs/help-fastapi.md
  41. 10
      docs/de/docs/how-to/custom-docs-ui-assets.md
  42. 20
      docs/de/docs/how-to/custom-request-and-route.md
  43. 5
      docs/de/docs/how-to/extending-openapi.md
  44. 10
      docs/de/docs/how-to/graphql.md
  45. 5
      docs/de/docs/how-to/index.md
  46. 53
      docs/de/docs/how-to/separate-openapi-schemas.md
  47. 111
      docs/de/docs/python-types.md
  48. 5
      docs/de/docs/reference/index.md
  49. 5
      docs/de/docs/reference/request.md
  50. 5
      docs/de/docs/reference/websockets.md
  51. 30
      docs/de/docs/tutorial/background-tasks.md
  52. 87
      docs/de/docs/tutorial/bigger-applications.md
  53. 80
      docs/de/docs/tutorial/body-fields.md
  54. 143
      docs/de/docs/tutorial/body-multiple-params.md
  55. 123
      docs/de/docs/tutorial/body-nested-models.md
  56. 73
      docs/de/docs/tutorial/body-updates.md
  57. 63
      docs/de/docs/tutorial/body.md
  58. 70
      docs/de/docs/tutorial/cookie-params.md
  59. 293
      docs/de/docs/tutorial/dependencies/classes-as-dependencies.md
  60. 78
      docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
  61. 104
      docs/de/docs/tutorial/dependencies/dependencies-with-yield.md
  62. 17
      docs/de/docs/tutorial/dependencies/global-dependencies.md
  63. 127
      docs/de/docs/tutorial/dependencies/index.md
  64. 113
      docs/de/docs/tutorial/dependencies/sub-dependencies.md
  65. 13
      docs/de/docs/tutorial/encoder.md
  66. 60
      docs/de/docs/tutorial/extra-data-types.md
  67. 60
      docs/de/docs/tutorial/extra-models.md
  68. 30
      docs/de/docs/tutorial/first-steps.md
  69. 20
      docs/de/docs/tutorial/handling-errors.md
  70. 144
      docs/de/docs/tutorial/header-params.md
  71. 5
      docs/de/docs/tutorial/index.md
  72. 15
      docs/de/docs/tutorial/metadata.md
  73. 15
      docs/de/docs/tutorial/middleware.md
  74. 80
      docs/de/docs/tutorial/path-operation-configuration.md
  75. 166
      docs/de/docs/tutorial/path-params-numeric-validations.md
  76. 40
      docs/de/docs/tutorial/path-params.md
  77. 493
      docs/de/docs/tutorial/query-params-str-validations.md
  78. 42
      docs/de/docs/tutorial/query-params.md
  79. 190
      docs/de/docs/tutorial/request-files.md
  80. 44
      docs/de/docs/tutorial/request-forms-and-files.md
  81. 59
      docs/de/docs/tutorial/request-forms.md
  82. 178
      docs/de/docs/tutorial/response-model.md
  83. 30
      docs/de/docs/tutorial/response-status-code.md
  84. 152
      docs/de/docs/tutorial/schema-extra-example.md
  85. 86
      docs/de/docs/tutorial/security/first-steps.md
  86. 177
      docs/de/docs/tutorial/security/get-current-user.md
  87. 9
      docs/de/docs/tutorial/security/index.md
  88. 150
      docs/de/docs/tutorial/security/oauth2-jwt.md
  89. 190
      docs/de/docs/tutorial/security/simple-oauth2.md
  90. 5
      docs/de/docs/tutorial/static-files.md
  91. 55
      docs/de/docs/tutorial/testing.md
  92. 25
      docs/em/docs/advanced/additional-responses.md
  93. 10
      docs/em/docs/advanced/additional-status-codes.md
  94. 5
      docs/em/docs/advanced/advanced-dependencies.md
  95. 15
      docs/em/docs/advanced/async-tests.md
  96. 35
      docs/em/docs/advanced/behind-a-proxy.md
  97. 55
      docs/em/docs/advanced/custom-response.md
  98. 5
      docs/em/docs/advanced/dataclasses.md
  99. 25
      docs/em/docs/advanced/events.md
  100. 29
      docs/em/docs/advanced/generate-clients.md

23
.github/workflows/build-docs.yml

@ -18,7 +18,7 @@ jobs:
docs: ${{ steps.filter.outputs.docs }}
steps:
- uses: actions/checkout@v4
# For pull requests it's not necessary to checkout the code but for master it is
# For pull requests it's not necessary to checkout the code but for the main branch it is
- uses: dorny/paths-filter@v3
id: filter
with:
@ -28,9 +28,12 @@ jobs:
- docs/**
- docs_src/**
- requirements-docs.txt
- requirements-docs-insiders.txt
- pyproject.toml
- mkdocs.yml
- mkdocs.insiders.yml
- mkdocs.maybe-insiders.yml
- mkdocs.no-insiders.yml
- .github/workflows/build-docs.yml
- .github/workflows/deploy-docs.yml
langs:
@ -49,17 +52,16 @@ jobs:
id: cache
with:
path: ${{ env.pythonLocation }}
key: ${{ runner.os }}-python-docs-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml', 'requirements-docs.txt', 'requirements-docs-tests.txt') }}-v07
key: ${{ runner.os }}-python-docs-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml', 'requirements-docs.txt', 'requirements-docs-insiders.txt', 'requirements-docs-tests.txt') }}-v08
- name: Install docs extras
if: steps.cache.outputs.cache-hit != 'true'
run: pip install -r requirements-docs.txt
# Install MkDocs Material Insiders here just to put it in the cache for the rest of the steps
- name: Install Material for MkDocs Insiders
if: ( github.event_name != 'pull_request' || github.secret_source == 'Actions' ) && steps.cache.outputs.cache-hit != 'true'
run: |
pip install git+https://${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}@github.com/squidfunk/mkdocs-material-insiders.git
pip install git+https://${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}@github.com/pawamoy-insiders/griffe-typing-deprecated.git
pip install git+https://${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}@github.com/pawamoy-insiders/mkdocstrings-python.git
run: pip install -r requirements-docs-insiders.txt
env:
TOKEN: ${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}
- name: Verify Docs
run: python ./scripts/docs.py verify-docs
- name: Export Language Codes
@ -90,16 +92,15 @@ jobs:
id: cache
with:
path: ${{ env.pythonLocation }}
key: ${{ runner.os }}-python-docs-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml', 'requirements-docs.txt', 'requirements-docs-tests.txt') }}-v08
key: ${{ runner.os }}-python-docs-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml', 'requirements-docs.txt', 'requirements-docs-insiders.txt', 'requirements-docs-tests.txt') }}-v08
- name: Install docs extras
if: steps.cache.outputs.cache-hit != 'true'
run: pip install -r requirements-docs.txt
- name: Install Material for MkDocs Insiders
if: ( github.event_name != 'pull_request' || github.secret_source == 'Actions' ) && steps.cache.outputs.cache-hit != 'true'
run: |
pip install git+https://${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}@github.com/squidfunk/mkdocs-material-insiders.git
pip install git+https://${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}@github.com/pawamoy-insiders/griffe-typing-deprecated.git
pip install git+https://${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}@github.com/pawamoy-insiders/mkdocstrings-python.git
run: pip install -r requirements-docs-insiders.txt
env:
TOKEN: ${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}
- name: Update Languages
run: python ./scripts/docs.py update-languages
- uses: actions/cache@v4

111
docs/bn/docs/python-types.md

@ -12,9 +12,12 @@ Python-เฆ เฆเฆšเงเฆ›เฆฟเฆ• "เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸ" (เฆฏเฆพ "เฆŸเฆพเฆ‡
เฆคเฆฌเง‡, เฆ†เฆชเฆจเฆฟ เฆฏเฆฆเฆฟ เฆ•เฆ–เฆจเง‹ **FastAPI** เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆจเฆพเฆ“ เฆ•เฆฐเง‡เฆจ, เฆคเฆฌเงเฆ“ เฆเฆ—เงเฆฒเฆฟ เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆเฆ•เฆŸเง เฆถเง‡เฆ–เฆพ เฆ†เฆชเฆจเฆพเฆฐ เฆ‰เฆชเฆ•เฆพเฆฐเง‡ เฆ†เฆธเฆฌเง‡เฅค
!!! Note
/// note
เฆฏเฆฆเฆฟ เฆ†เฆชเฆจเฆฟ เฆเฆ•เฆœเฆจ Python เฆฌเฆฟเฆถเง‡เฆทเฆœเงเฆž เฆนเฆจ, เฆเฆฌเฆ‚ เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸ เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆธเฆฌเฆ•เฆฟเฆ›เง เฆœเฆพเฆจเง‡เฆจ, เฆคเฆพเฆนเฆฒเง‡ เฆชเฆฐเฆฌเฆฐเงเฆคเง€ เฆ…เฆงเงเฆฏเฆพเฆฏเฆผเง‡ เฆšเฆฒเง‡ เฆฏเฆพเฆจเฅค
///
## เฆชเงเฆฐเง‡เฆฐเฆฃเฆพ
เฆšเฆฒเงเฆจ เฆเฆ•เฆŸเฆฟ เฆธเฆพเฆงเฆพเฆฐเฆฃ เฆ‰เฆฆเฆพเฆนเฆฐเฆฃ เฆฆเฆฟเฆฏเฆผเง‡ เฆถเงเฆฐเง เฆ•เฆฐเฆฟ:
@ -170,7 +173,7 @@ Python เฆฏเฆค เฆเฆ—เฆฟเฆฏเฆผเง‡ เฆฏเฆพเฆšเงเฆ›เง‡, **เฆจเฆคเงเฆจ เฆธเฆ‚เฆธเง
เฆ‰เฆฆเฆพเฆนเฆฐเฆฃเฆธเงเฆฌเฆฐเง‚เฆช, เฆเฆ•เฆŸเฆฟ เฆญเง‡เฆฐเฆฟเฆฏเฆผเง‡เฆฌเฆฒเฆ•เง‡ `str`-เฆเฆฐ เฆเฆ•เฆŸเฆฟ `list` เฆนเฆฟเฆธเง‡เฆฌเง‡ เฆธเฆ‚เฆœเงเฆžเฆพเฆฏเฆผเฆฟเฆค เฆ•เฆฐเฆพ เฆฏเฆพเฆ•เฅค
=== "Python 3.9+"
//// tab | Python 3.9+
เฆญเง‡เฆฐเฆฟเฆฏเฆผเง‡เฆฌเฆฒเฆŸเฆฟ เฆ˜เง‹เฆทเฆฃเฆพ เฆ•เฆฐเงเฆจ, เฆเฆ•เฆ‡ เฆ•เง‹เฆฒเฆจ (`:`) เฆธเฆฟเฆจเฆŸเงเฆฏเฆพเฆ•เงเฆธ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡เฅค
@ -182,7 +185,9 @@ Python เฆฏเฆค เฆเฆ—เฆฟเฆฏเฆผเง‡ เฆฏเฆพเฆšเงเฆ›เง‡, **เฆจเฆคเงเฆจ เฆธเฆ‚เฆธเง
{!> ../../../docs_src/python_types/tutorial006_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
`typing` เฆฅเง‡เฆ•เง‡ `List` (เฆฌเฆกเฆผ เฆนเฆพเฆคเง‡เฆฐ `L` เฆฆเฆฟเฆฏเฆผเง‡) เฆ‡เฆฎเฆชเง‹เฆฐเงเฆŸ เฆ•เฆฐเงเฆจ:
@ -200,16 +205,24 @@ Python เฆฏเฆค เฆเฆ—เฆฟเฆฏเฆผเง‡ เฆฏเฆพเฆšเงเฆ›เง‡, **เฆจเฆคเงเฆจ เฆธเฆ‚เฆธเง
{!> ../../../docs_src/python_types/tutorial006.py!}
```
!!! Info
////
/// info
เฆธเงเฆ•เง‹เฆฏเฆผเฆพเฆฐ เฆฌเงเฆฐเฆพเฆ•เง‡เฆŸ เฆเฆฐ เฆญเฆฟเฆคเฆฐเง‡ เฆฌเงเฆฏเฆฌเฆนเงƒเฆค เฆเฆ‡เฆธเฆฌ เฆ…เฆญเฆจเงเฆคเฆฐเง€เฆจ เฆŸเฆพเฆ‡เฆชเฆ—เงเฆฒเง‹เฆ•เง‡ "เฆ‡เฆจเงเฆŸเฆพเฆฐเฆจเฆพเฆฒ เฆŸเฆพเฆ‡เฆช" เฆฌเฆฒเง‡เฅค
เฆเฆ‡ เฆ‰เฆฆเฆพเฆนเฆฐเฆฃเง‡, เฆเฆŸเฆฟ เฆนเฆšเงเฆ›เง‡ `List`(เฆ…เฆฅเฆฌเฆพ เฆชเฆพเฆ‡เฆฅเฆจ เงฉ.เงฏ เฆฌเฆพ เฆคเฆพเฆฐ เฆ‰เฆชเฆฐเง‡เฆฐ เฆธเฆ‚เฆธเงเฆ•เฆฐเฆฃเง‡เฆฐ เฆ•เงเฆทเง‡เฆคเงเฆฐเง‡ `list`) เฆ เฆชเฆพเฆธ เฆ•เฆฐเฆพ เฆŸเฆพเฆ‡เฆช เฆชเงเฆฏเฆพเฆฐเฆพเฆฎเฆฟเฆŸเฆพเฆฐเฅค
///
เฆเฆฐ เฆ…เฆฐเงเฆฅ เฆนเฆšเงเฆ›เง‡: "เฆญเง‡เฆฐเฆฟเฆฏเฆผเง‡เฆฌเฆฒ `items` เฆเฆ•เฆŸเฆฟ `list`, เฆเฆฌเฆ‚ เฆเฆ‡ เฆฒเฆฟเฆธเงเฆŸเง‡เฆฐ เฆชเงเฆฐเฆคเฆฟเฆŸเฆฟ เฆ†เฆ‡เฆŸเง‡เฆฎ เฆเฆ•เฆŸเฆฟ `str`เฅค"
!!! Tip
/// tip
เฆฏเฆฆเฆฟ เฆ†เฆชเฆจเฆฟ Python 3.9 เฆฌเฆพ เฆคเฆพเฆฐ เฆ‰เฆชเฆฐเง‡ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡เฆจ, เฆ†เฆชเฆจเฆพเฆฐ `typing` เฆฅเง‡เฆ•เง‡ `List` เฆ†เฆฎเฆฆเฆพเฆจเฆฟ เฆ•เฆฐเฆคเง‡ เฆนเฆฌเง‡ เฆจเฆพ, เฆ†เฆชเฆจเฆฟ เฆธเฆพเฆงเฆพเฆฐเฆฃ `list` เฆ“เฆ‡ เฆŸเฆพเฆ‡เฆชเง‡เฆฐ เฆชเฆฐเฆฟเฆฌเฆฐเงเฆคเง‡ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจเฅค
///
เฆเฆฐ เฆฎเฆพเฆงเงเฆฏเฆฎเง‡, เฆ†เฆชเฆจเฆพเฆฐ เฆเฆกเฆฟเฆŸเฆฐ เฆฒเฆฟเฆธเงเฆŸ เฆฅเง‡เฆ•เง‡ เฆ†เฆ‡เฆŸเง‡เฆฎ เฆชเงเฆฐเฆธเง‡เฆธ เฆ•เฆฐเฆพเฆฐ เฆธเฆฎเฆฏเฆผ เฆธเฆพเฆชเง‹เฆฐเงเฆŸ เฆชเงเฆฐเฆฆเฆพเฆจ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเฆฌเง‡:
<img src="/img/python-types/image05.png">
@ -224,18 +237,22 @@ Python เฆฏเฆค เฆเฆ—เฆฟเฆฏเฆผเง‡ เฆฏเฆพเฆšเงเฆ›เง‡, **เฆจเฆคเงเฆจ เฆธเฆ‚เฆธเง
เฆ†เฆชเฆจเฆฟ `tuple` เฆเฆฌเฆ‚ `set` เฆ˜เง‹เฆทเฆฃเฆพ เฆ•เฆฐเฆพเฆฐ เฆœเฆจเงเฆฏ เฆเฆ•เฆ‡ เฆชเงเฆฐเฆ•เงเฆฐเฆฟเฆฏเฆผเฆพ เฆ…เฆจเงเฆธเฆฐเฆฃ เฆ•เฆฐเฆฌเง‡เฆจ:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial007_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial007.py!}
```
////
เฆเฆฐ เฆฎเฆพเฆจเง‡ เฆนเฆฒ:
* เฆญเง‡เฆฐเฆฟเฆฏเฆผเง‡เฆฌเฆฒ `items_t` เฆนเฆฒ เฆเฆ•เฆŸเฆฟ `tuple` เฆฏเฆพ เงฉเฆŸเฆฟ เฆ†เฆ‡เฆŸเง‡เฆฎ เฆงเฆพเฆฐเฆฃ เฆ•เฆฐเง‡, เฆเฆ•เฆŸเฆฟ `int`, เฆ…เฆจเงเฆฏ เฆเฆ•เฆŸเฆฟ `int`, เฆเฆฌเฆ‚ เฆเฆ•เฆŸเฆฟ `str`เฅค
@ -249,18 +266,21 @@ Python เฆฏเฆค เฆเฆ—เฆฟเฆฏเฆผเง‡ เฆฏเฆพเฆšเงเฆ›เง‡, **เฆจเฆคเงเฆจ เฆธเฆ‚เฆธเง
เฆฆเงเฆฌเฆฟเฆคเง€เฆฏเฆผ เฆŸเฆพเฆ‡เฆช เฆชเงเฆฏเฆพเฆฐเฆพเฆฎเฆฟเฆŸเฆพเฆฐเฆŸเฆฟ เฆนเฆฒ `dict`-เฆเฆฐ เฆฎเฆพเฆจเฆ—เงเฆฒเฆฟเฆฐ เฆœเฆจเงเฆฏ:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial008_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial008.py!}
```
////
เฆเฆฐ เฆฎเฆพเฆจเง‡ เฆนเฆฒ:
@ -276,18 +296,22 @@ Python 3.6 เฆเฆฌเฆ‚ เฆคเฆพเฆฐ เฆ‰เฆชเฆฐเง‡เฆฐ เฆธเฆ‚เฆธเงเฆ•เฆฐเฆฃเฆ—เงเฆฒเฆฟ
Python 3.10-เฆ เฆเฆ•เฆŸเฆฟ **เฆจเฆคเงเฆจ เฆธเฆฟเฆจเฆŸเงเฆฏเฆพเฆ•เงเฆธ** เฆ†เฆ›เง‡ เฆฏเง‡เฆ–เฆพเฆจเง‡ เฆ†เฆชเฆจเฆฟ เฆธเฆฎเงเฆญเฆพเฆฌเงเฆฏ เฆŸเฆพเฆ‡เฆชเฆ—เงเฆฒเฆฟเฆ•เง‡ เฆเฆ•เฆŸเฆฟ <abbr title="เฆ‰เฆฒเงเฆฒเฆฎเงเฆฌ เฆฌเฆพเฆฐเฆพเฆฒเฆ•เง‡ 'เฆฌเฆฟเฆŸเฆ“เฆฏเฆผเฆพเฆ‡เฆœ เฆฌเฆพ เฆ…เฆชเฆพเฆฐเง‡เฆŸเฆฐ' เฆฌเฆฒเฆพ เฆนเฆฏเฆผ, เฆ•เฆฟเฆจเงเฆคเง เฆธเง‡เฆ‡ เฆ…เฆฐเงเฆฅ เฆเฆ–เฆพเฆจเง‡ เฆชเงเฆฐเฆพเฆธเฆ™เงเฆ—เฆฟเฆ• เฆจเฆฏเฆผ">เฆญเฆพเฆฐเงเฆŸเฆฟเฆ•เฆพเฆฒ เฆฌเฆพเฆฐ (`|`)</abbr> เฆฆเงเฆฌเฆพเฆฐเฆพ เฆชเงƒเฆฅเฆ• เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจเฅค
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial008b_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial008b.py!}
```
////
เฆ‰เฆญเฆฏเฆผ เฆ•เงเฆทเง‡เฆคเงเฆฐเง‡เฆ‡ เฆเฆฐ เฆฎเฆพเฆจเง‡ เฆนเฆฒ เฆฏเง‡ `item` เฆนเฆคเง‡ เฆชเฆพเฆฐเง‡ เฆเฆ•เฆŸเฆฟ `int` เฆ…เฆฅเฆฌเฆพ `str`เฅค
#### เฆธเฆฎเงเฆญเฆฌเฆค `None`
@ -306,24 +330,30 @@ Python 3.6 เฆเฆฌเฆ‚ เฆคเฆพเฆฐ เฆ‰เฆชเฆฐเง‡เฆฐ เฆธเฆ‚เฆธเงเฆ•เฆฐเฆฃเฆ—เงเฆฒเฆฟ
เฆเฆฐ เฆฎเฆพเฆจเง‡ เฆนเฆฒ, Python 3.10-เฆ, เฆ†เฆชเฆจเฆฟ เฆŸเฆพเฆ‡เฆชเฆ—เงเฆฒเฆฟเฆฐ เฆ‡เฆ‰เฆจเฆฟเฆฏเฆผเฆจ เฆ˜เง‹เฆทเฆฃเฆพ เฆ•เฆฐเฆคเง‡ `Something | None` เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจ:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial009_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial009.py!}
```
=== "Python 3.8+ เฆฌเฆฟเฆ•เฆฒเงเฆช"
////
//// tab | Python 3.8+ เฆฌเฆฟเฆ•เฆฒเงเฆช
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial009b.py!}
```
////
#### `Union` เฆฌเฆพ `Optional` เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ
เฆฏเฆฆเฆฟ เฆ†เฆชเฆจเฆฟ Python 3.10-เฆเฆฐ เฆจเง€เฆšเง‡เฆฐ เฆธเฆ‚เฆธเงเฆ•เฆฐเฆฃ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡เฆจ, เฆคเฆฌเง‡ เฆเฆ–เฆพเฆจเง‡ เฆ†เฆฎเฆพเฆฐ เฆ–เงเฆฌเฆ‡ **เฆฌเงเฆฏเฆ•เงเฆคเฆฟเฆ—เฆค** เฆฆเงƒเฆทเงเฆŸเฆฟเฆญเฆ™เงเฆ—เฆฟ เฆฅเง‡เฆ•เง‡ เฆเฆ•เฆŸเฆฟ เฆŸเฆฟเฆชเฆธ:
@ -367,7 +397,8 @@ say_hi(name=None) # เฆเฆŸเฆฟ เฆ•เฆพเฆœ เฆ•เฆฐเง‡, None เฆฌเงˆเฆง ๐ŸŽ‰
เฆธเงเฆ•เง‹เฆฏเฆผเฆพเฆฐ เฆฌเงเฆฐเงเฆฏเฆพเฆ•เง‡เฆŸเง‡ เฆŸเฆพเฆ‡เฆช เฆชเงเฆฏเฆพเฆฐเฆพเฆฎเฆฟเฆŸเฆพเฆฐ เฆจเง‡เฆ“เฆฏเฆผเฆพ เฆเฆ‡ เฆŸเฆพเฆ‡เฆชเฆ—เงเฆฒเฆฟเฆ•เง‡ **เฆœเง‡เฆจเง‡เฆฐเฆฟเฆ• เฆŸเฆพเฆ‡เฆช** เฆฌเฆพ **เฆœเง‡เฆจเง‡เฆฐเฆฟเฆ•เฆธ** เฆฌเฆฒเฆพ เฆนเฆฏเฆผ, เฆฏเง‡เฆฎเฆจ:
=== "Python 3.10+"
//// tab | Python 3.10+
เฆ†เฆชเฆจเฆฟ เฆธเง‡เฆ‡ เฆเฆ•เฆ‡ เฆฌเฆฟเฆฒเงเฆŸเฆ‡เฆจ เฆŸเฆพเฆ‡เฆช เฆœเง‡เฆจเง‡เฆฐเฆฟเฆ•เงเฆธ เฆนเฆฟเฆธเง‡เฆฌเง‡ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเฆฌเง‡เฆจ(เฆญเฆฟเฆคเฆฐเง‡ เฆŸเฆพเฆ‡เฆช เฆธเฆน เฆธเงเฆ•เฆฏเฆผเฆพเฆฐเง‡ เฆฌเงเฆฐเฆพเฆ•เง‡เฆŸ เฆฆเฆฟเฆฏเฆผเง‡):
* `list`
@ -383,7 +414,9 @@ say_hi(name=None) # เฆเฆŸเฆฟ เฆ•เฆพเฆœ เฆ•เฆฐเง‡, None เฆฌเงˆเฆง ๐ŸŽ‰
Python 3.10-เฆ, `Union` เฆเฆฌเฆ‚ `Optional` เฆœเง‡เฆจเง‡เฆฐเฆฟเฆ•เฆธ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆพเฆฐ เฆฌเฆฟเฆ•เฆฒเงเฆช เฆนเฆฟเฆธเง‡เฆฌเง‡, เฆ†เฆชเฆจเฆฟ เฆŸเฆพเฆ‡เฆชเฆ—เงเฆฒเฆฟเฆฐ เฆ‡เฆ‰เฆจเฆฟเฆฏเฆผเฆจ เฆ˜เง‹เฆทเฆฃเฆพ เฆ•เฆฐเฆคเง‡ <abbr title="เฆ‰เฆฒเงเฆฒเฆฎเงเฆฌ เฆฌเฆพเฆฐเฆพเฆฒเฆ•เง‡ 'เฆฌเฆฟเฆŸเฆ“เฆฏเฆผเฆพเฆ‡เฆœ เฆฌเฆพ เฆ…เฆชเฆพเฆฐเง‡เฆŸเฆฐ' เฆฌเฆฒเฆพ เฆนเฆฏเฆผ, เฆ•เฆฟเฆจเงเฆคเง เฆธเง‡เฆ‡ เฆ…เฆฐเงเฆฅ เฆเฆ–เฆพเฆจเง‡ เฆชเงเฆฐเฆพเฆธเฆ™เงเฆ—เฆฟเฆ• เฆจเฆฏเฆผ">เฆญเฆพเฆฐเงเฆŸเฆฟเฆ•เฆพเฆฒ เฆฌเฆพเฆฐ (`|`)</abbr> เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจ, เฆฏเฆพ เฆ“เฆฆเง‡เฆฐ เฆฅเง‡เฆ•เง‡ เฆ…เฆจเง‡เฆ• เฆญเฆพเฆฒเง‹ เฆเฆฌเฆ‚ เฆธเฆนเฆœเฅค
=== "Python 3.9+"
////
//// tab | Python 3.9+
เฆ†เฆชเฆจเฆฟ เฆธเง‡เฆ‡ เฆเฆ•เฆ‡ เฆฌเฆฟเฆฒเงเฆŸเฆ‡เฆจ เฆŸเฆพเฆ‡เฆช เฆœเง‡เฆจเง‡เฆฐเฆฟเฆ•เงเฆธ เฆนเฆฟเฆธเง‡เฆฌเง‡ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเฆฌเง‡เฆจ(เฆญเฆฟเฆคเฆฐเง‡ เฆŸเฆพเฆ‡เฆช เฆธเฆน เฆธเงเฆ•เฆฏเฆผเฆพเฆฐเง‡ เฆฌเงเฆฐเฆพเฆ•เง‡เฆŸ เฆฆเฆฟเฆฏเฆผเง‡):
@ -398,7 +431,9 @@ say_hi(name=None) # เฆเฆŸเฆฟ เฆ•เฆพเฆœ เฆ•เฆฐเง‡, None เฆฌเงˆเฆง ๐ŸŽ‰
* `Optional`
* ...เฆเฆฌเฆ‚ เฆ…เฆจเงเฆฏเฆพเฆจเงเฆฏเฅค
=== "Python 3.8+"
////
//// tab | Python 3.8+
* `List`
* `Tuple`
@ -408,6 +443,8 @@ say_hi(name=None) # เฆเฆŸเฆฟ เฆ•เฆพเฆœ เฆ•เฆฐเง‡, None เฆฌเงˆเฆง ๐ŸŽ‰
* `Optional`
* ...เฆเฆฌเฆ‚ เฆ…เฆจเงเฆฏเฆพเฆจเงเฆฏเฅค
////
### เฆ•เงเฆฒเฆพเฆธ เฆนเฆฟเฆธเง‡เฆฌเง‡ เฆŸเฆพเฆ‡เฆชเฆธ
เฆ†เฆชเฆจเฆฟ เฆเฆ•เฆŸเฆฟ เฆญเง‡เฆฐเฆฟเฆฏเฆผเง‡เฆฌเฆฒเง‡เฆฐ เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆธเง‡เฆฌเง‡ เฆเฆ•เฆŸเฆฟ เฆ•เงเฆฒเฆพเฆธ เฆ˜เง‹เฆทเฆฃเฆพ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจเฅค
@ -446,39 +483,51 @@ say_hi(name=None) # เฆเฆŸเฆฟ เฆ•เฆพเฆœ เฆ•เฆฐเง‡, None เฆฌเงˆเฆง ๐ŸŽ‰
เฆ…เฆซเฆฟเฆธเฆฟเฆฏเฆผเฆพเฆฒ Pydantic เฆกเฆ•เงเฆธ เฆฅเง‡เฆ•เง‡ เฆเฆ•เฆŸเฆฟ เฆ‰เฆฆเฆพเฆนเฆฐเฆฃ:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python
{!> ../../../docs_src/python_types/tutorial011_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python
{!> ../../../docs_src/python_types/tutorial011_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python
{!> ../../../docs_src/python_types/tutorial011.py!}
```
!!! Info
////
/// info
[Pydantic เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆ†เฆฐเฆ“ เฆœเฆพเฆจเฆคเง‡, เฆเฆฐ เฆกเฆ•เงเฆฎเง‡เฆจเงเฆŸเง‡เฆถเฆจ เฆฆเง‡เฆ–เงเฆจ](https://docs.pydantic.dev/)เฅค
///
**FastAPI** เฆฎเง‚เฆฒเฆค Pydantic-เฆเฆฐ เฆ‰เฆชเฆฐ เฆจเฆฟเฆฐเงเฆฎเฆฟเฆคเฅค
เฆ†เฆชเฆจเฆฟ เฆเฆ‡ เฆธเฆฎเฆธเงเฆค เฆ•เฆฟเฆ›เงเฆฐ เฆ…เฆจเง‡เฆ• เฆฌเฆพเฆธเงเฆคเฆฌเฆธเฆฎเงเฆฎเฆค เฆ‰เฆฆเฆพเฆนเฆฐเฆฃ เฆชเฆพเฆฌเง‡เฆจ [เฆŸเฆฟเฆ‰เฆŸเง‹เฆฐเฆฟเฆฏเฆผเฆพเฆฒ - เฆ‡เฆ‰เฆœเฆพเฆฐ เฆ—เฆพเฆ‡เฆกเง‡](https://fastapi.tiangolo.com/tutorial/)เฅค
!!! Tip
/// tip
เฆฏเฆ–เฆจ เฆ†เฆชเฆจเฆฟ `Optional` เฆฌเฆพ `Union[Something, None]` เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡เฆจ เฆเฆฌเฆ‚ เฆ•เง‹เฆจเง‹ เฆกเฆฟเฆซเฆฒเงเฆŸ เฆฎเฆพเฆจ เฆจเฆพ เฆฅเฆพเฆ•เง‡, Pydantic-เฆเฆฐ เฆเฆ•เฆŸเฆฟ เฆฌเฆฟเฆถเง‡เฆท เฆ†เฆšเฆฐเฆฃ เฆฐเฆฏเฆผเง‡เฆ›เง‡, เฆ†เฆชเฆจเฆฟ Pydantic เฆกเฆ•เงเฆฎเง‡เฆจเงเฆŸเง‡เฆถเฆจเง‡ [Required Optional fields](https://docs.pydantic.dev/latest/concepts/models/#required-optional-fields) เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆ†เฆฐเฆ“ เฆชเฆกเฆผเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจเฅค
///
## เฆฎเง‡เฆŸเฆพเฆกเฆพเฆŸเฆพ เฆ…เงเฆฏเฆพเฆจเง‹เฆŸเง‡เฆถเฆจ เฆธเฆน เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸเฆธ
Python-เฆ เฆเฆฎเฆจ เฆเฆ•เฆŸเฆฟ เฆซเฆฟเฆšเฆพเฆฐ เฆ†เฆ›เง‡ เฆฏเฆพ `Annotated` เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡ เฆเฆ‡ เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸเฆ—เงเฆฒเฆฟเฆคเง‡ **เฆ…เฆคเฆฟเฆฐเฆฟเฆ•เงเฆค เฆฎเง‡เฆŸเฆพเฆกเฆพเฆŸเฆพ** เฆฐเฆพเฆ–เฆคเง‡ เฆฆเง‡เฆฏเฆผเฅค
=== "Python 3.9+"
//// tab | Python 3.9+
Python 3.9-เฆ, `Annotated` เฆธเงเฆŸเงเฆฏเฆพเฆจเงเฆกเฆพเฆฐเงเฆก เฆฒเฆพเฆ‡เฆฌเงเฆฐเง‡เฆฐเฆฟเฆคเง‡ เฆ…เฆจเงเฆคเฆฐเงเฆญเงเฆ•เงเฆค, เฆคเฆพเฆ‡ เฆ†เฆชเฆจเฆฟ เฆเฆŸเฆฟ `typing` เฆฅเง‡เฆ•เง‡ เฆ‡เฆฎเฆชเง‹เฆฐเงเฆŸ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจเฅค
@ -486,7 +535,9 @@ Python-เฆ เฆเฆฎเฆจ เฆเฆ•เฆŸเฆฟ เฆซเฆฟเฆšเฆพเฆฐ เฆ†เฆ›เง‡ เฆฏเฆพ `Annotated`
{!> ../../../docs_src/python_types/tutorial013_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
Python 3.9-เฆเฆฐ เฆจเง€เฆšเง‡เฆฐ เฆธเฆ‚เฆธเงเฆ•เฆฐเฆฃเฆ—เงเฆฒเฆฟเฆคเง‡, เฆ†เฆชเฆจเฆฟ `Annotated`-เฆ•เง‡ `typing_extensions` เฆฅเง‡เฆ•เง‡ เฆ‡เฆฎเฆชเง‹เฆฐเงเฆŸ เฆ•เฆฐเง‡เฆจเฅค
@ -496,6 +547,8 @@ Python-เฆ เฆเฆฎเฆจ เฆเฆ•เฆŸเฆฟ เฆซเฆฟเฆšเฆพเฆฐ เฆ†เฆ›เง‡ เฆฏเฆพ `Annotated`
{!> ../../../docs_src/python_types/tutorial013.py!}
```
////
Python เฆจเฆฟเฆœเง‡ เฆเฆ‡ `Annotated` เฆฆเฆฟเฆฏเฆผเง‡ เฆ•เฆฟเฆ›เงเฆ‡ เฆ•เฆฐเง‡ เฆจเฆพเฅค เฆเฆฌเฆ‚ เฆเฆกเฆฟเฆŸเฆฐ เฆเฆฌเฆ‚ เฆ…เฆจเงเฆฏเฆพเฆจเงเฆฏ เฆŸเงเฆฒเฆ—เงเฆฒเฆฟเฆฐ เฆœเฆจเงเฆฏ, เฆŸเฆพเฆ‡เฆชเฆŸเฆฟ เฆเฆ–เฆจเฆ“ `str`เฅค
เฆ•เฆฟเฆจเงเฆคเง เฆ†เฆชเฆจเฆฟ เฆเฆ‡ `Annotated` เฆเฆฐ เฆฎเฆงเงเฆฏเฆ•เฆพเฆฐ เฆœเฆพเฆฏเฆผเฆ—เฆพเฆŸเฆฟเฆฐ เฆฎเฆงเงเฆฏเง‡ **FastAPI**-เฆ เฆ•เง€เฆญเฆพเฆฌเง‡ เฆ†เฆชเฆจเฆพเฆฐ เฆ…เงเฆฏเฆพเฆชเงเฆฒเฆฟเฆ•เง‡เฆถเฆจ เฆ†เฆšเฆฐเฆฃ เฆ•เฆฐเงเฆ• เฆคเฆพ เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆ…เฆคเฆฟเฆฐเฆฟเฆ•เงเฆค เฆฎเง‡เฆŸเฆพเฆกเฆพเฆŸเฆพ เฆชเงเฆฐเฆฆเฆพเฆจ เฆ•เฆฐเฆพเฆฐ เฆœเฆจเงเฆฏ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเฆคเง‡ เฆชเฆพเฆฐเง‡เฆจเฅค
@ -506,11 +559,14 @@ Python เฆจเฆฟเฆœเง‡ เฆเฆ‡ `Annotated` เฆฆเฆฟเฆฏเฆผเง‡ เฆ•เฆฟเฆ›เงเฆ‡ เฆ•เฆฐเง‡
เฆชเฆฐเฆฌเฆฐเงเฆคเง€เฆคเง‡ เฆ†เฆชเฆจเฆฟ เฆฆเง‡เฆ–เฆฌเง‡เฆจ เฆเฆŸเฆฟ เฆ•เฆคเฆŸเฆพ **เฆถเฆ•เงเฆคเฆฟเฆถเฆพเฆฒเง€** เฆนเฆคเง‡ เฆชเฆพเฆฐเง‡เฅค
!!! Tip
/// tip
เฆเฆŸเฆฟ **เฆธเงเฆŸเงเฆฏเฆพเฆจเงเฆกเฆพเฆฐเงเฆก Python** เฆนเฆ“เฆฏเฆผเฆพเฆฐ เฆฎเฆพเฆจเง‡ เฆนเฆฒ เฆ†เฆชเฆจเฆฟ เฆ†เฆชเฆจเฆพเฆฐ เฆเฆกเฆฟเฆŸเฆฐเง‡, เฆ†เฆชเฆจเฆฟ เฆฏเง‡ เฆŸเงเฆฒเฆ—เงเฆฒเฆฟ เฆ•เง‹เฆก เฆฌเฆฟเฆถเงเฆฒเง‡เฆทเฆฃ เฆเฆฌเฆ‚ เฆฐเฆฟเฆซเงเฆฏเฆพเฆ•เงเฆŸเฆฐ เฆ•เฆฐเฆพเฆฐ เฆœเฆจเงเฆฏ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡เฆจ เฆคเฆพเฆคเง‡ **เฆธเง‡เฆฐเฆพ เฆธเฆฎเงเฆญเฆพเฆฌเงเฆฏ เฆกเง‡เฆญเง‡เฆฒเฆชเฆพเฆฐ เฆเฆ•เงเฆธเฆชเง‡เฆฐเฆฟเฆฏเฆผเง‡เฆจเงเฆธ** เฆชเฆพเฆฌเง‡เฆจเฅค โœจ
เฆเฆฌเฆ‚ เฆเฆ›เฆพเฆกเฆผเฆพเฆ“ เฆ†เฆชเฆจเฆพเฆฐ เฆ•เง‹เฆก เฆ…เฆจเงเฆฏเฆพเฆจเงเฆฏ เฆ…เฆจเง‡เฆ• Python เฆŸเงเฆฒ เฆเฆฌเฆ‚ เฆฒเฆพเฆ‡เฆฌเงเฆฐเง‡เฆฐเฆฟเฆ—เงเฆฒเฆฟเฆฐ เฆธเฆพเฆฅเง‡ เฆ–เงเฆฌ เฆธเฆพเฆฎเฆžเงเฆœเฆธเงเฆฏเฆชเง‚เฆฐเงเฆฃ เฆนเฆฌเง‡เฅค ๐Ÿš€
///
## **FastAPI**-เฆ เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸเฆธ
**FastAPI** เฆเฆ‡ เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸเฆ—เงเฆฒเฆฟ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡ เฆฌเง‡เฆถ เฆ•เฆฟเฆ›เง เฆœเฆฟเฆจเฆฟเฆธ เฆ•เฆฐเง‡เฅค
@ -533,5 +589,8 @@ Python เฆจเฆฟเฆœเง‡ เฆเฆ‡ `Annotated` เฆฆเฆฟเฆฏเฆผเง‡ เฆ•เฆฟเฆ›เงเฆ‡ เฆ•เฆฐเง‡
เฆ—เงเฆฐเงเฆคเงเฆฌเฆชเง‚เฆฐเงเฆฃ เฆฌเฆฟเฆทเฆฏเฆผ เฆนเฆฒ, เฆ†เฆชเฆจเฆฟ เฆฏเฆฆเฆฟ เฆธเงเฆŸเงเฆฏเฆพเฆจเงเฆกเฆพเฆฐเงเฆก Python เฆŸเฆพเฆ‡เฆชเฆ—เงเฆฒเฆฟ เฆฌเงเฆฏเฆฌเฆนเฆพเฆฐ เฆ•เฆฐเง‡เฆจ, เฆคเฆฌเง‡ เฆ†เฆฐเฆ“ เฆฌเง‡เฆถเฆฟ เฆ•เงเฆฒเฆพเฆธ, เฆกเง‡เฆ•เง‹เฆฐเง‡เฆŸเฆฐ เฆ‡เฆคเงเฆฏเฆพเฆฆเฆฟ เฆฏเง‹เฆ— เฆจเฆพ เฆ•เฆฐเง‡เฆ‡ เฆเฆ•เฆ‡ เฆธเงเฆฅเฆพเฆจเง‡ **FastAPI** เฆ†เฆชเฆจเฆพเฆฐ เฆ…เฆจเง‡เฆ• เฆ•เฆพเฆœ เฆ•เฆฐเง‡ เฆฆเฆฟเฆฌเง‡เฅค
!!! Info
/// info
เฆฏเฆฆเฆฟ เฆ†เฆชเฆจเฆฟ เฆŸเฆฟเฆ‰เฆŸเง‹เฆฐเฆฟเฆฏเฆผเฆพเฆฒเง‡เฆฐ เฆธเฆฎเฆธเงเฆค เฆฌเฆฟเฆทเฆฏเฆผ เฆชเฆกเฆผเง‡ เฆซเง‡เฆฒเง‡ เฆฅเฆพเฆ•เง‡เฆจ เฆเฆฌเฆ‚ เฆŸเฆพเฆ‡เฆช เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆ†เฆฐเฆ“ เฆœเฆพเฆจเฆคเง‡ เฆšเฆพเฆจ, เฆคเฆฌเง‡ เฆเฆ•เฆŸเฆฟ เฆญเฆพเฆฒเง‹ เฆฐเฆฟเฆธเง‹เฆฐเงเฆธ เฆนเฆฒ [mypy เฆเฆฐ "cheat sheet"](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html)เฅค เฆเฆ‡ "cheat sheet" เฆ เฆ†เฆชเฆจเฆฟ Python เฆŸเฆพเฆ‡เฆช เฆนเฆฟเฆจเงเฆŸ เฆธเฆฎเงเฆชเฆฐเงเฆ•เง‡ เฆฌเง‡เฆธเฆฟเฆ• เฆฅเง‡เฆ•เง‡ เฆ‰เฆจเงเฆจเฆค เฆฒเง‡เฆญเง‡เฆฒเง‡เฆฐ เฆงเฆพเฆฐเฆฃเฆพ เฆชเง‡เฆคเง‡ เฆชเฆพเฆฐเง‡เฆจ, เฆฏเฆพ เฆ†เฆชเฆจเฆพเฆฐ เฆ•เง‹เฆกเง‡ เฆŸเฆพเฆ‡เฆช เฆธเง‡เฆซเฆŸเฆฟ เฆเฆฌเฆ‚ เฆธเงเฆชเฆทเงเฆŸเฆคเฆพ เฆฌเฆพเฆกเฆผเฆพเฆคเง‡ เฆธเฆพเฆนเฆพเฆฏเงเฆฏ เฆ•เฆฐเฆฌเง‡เฅค
///

25
docs/de/docs/advanced/additional-responses.md

@ -1,10 +1,13 @@
# Zusรคtzliche Responses in OpenAPI
!!! warning "Achtung"
/// warning | "Achtung"
Dies ist ein eher fortgeschrittenes Thema.
Wenn Sie mit **FastAPI** beginnen, benรถtigen Sie dies mรถglicherweise nicht.
///
Sie kรถnnen zusรคtzliche Responses mit zusรคtzlichen Statuscodes, Medientypen, Beschreibungen, usw. deklarieren.
Diese zusรคtzlichen Responses werden in das OpenAPI-Schema aufgenommen, sodass sie auch in der API-Dokumentation erscheinen.
@ -27,10 +30,14 @@ Um beispielsweise eine weitere Response mit dem Statuscode `404` und einem Pydan
{!../../../docs_src/additional_responses/tutorial001.py!}
```
!!! note "Hinweis"
/// note | "Hinweis"
Beachten Sie, dass Sie die `JSONResponse` direkt zurรผckgeben mรผssen.
!!! info
///
/// info
Der `model`-Schlรผssel ist nicht Teil von OpenAPI.
**FastAPI** nimmt das Pydantic-Modell von dort, generiert das JSON-Schema und fรผgt es an der richtigen Stelle ein.
@ -42,6 +49,8 @@ Um beispielsweise eine weitere Response mit dem Statuscode `404` und einem Pydan
* Ein Schlรผssel `schema`, der als Wert das JSON-Schema aus dem Modell hat, hier ist die richtige Stelle.
* **FastAPI** fรผgt hier eine Referenz auf die globalen JSON-Schemas an einer anderen Stelle in Ihrer OpenAPI hinzu, anstatt es direkt einzubinden. Auf diese Weise kรถnnen andere Anwendungen und Clients diese JSON-Schemas direkt verwenden, bessere Tools zur Codegenerierung bereitstellen, usw.
///
Die generierten Responses in der OpenAPI fรผr diese *Pfadoperation* lauten:
```JSON hl_lines="3-12"
@ -172,14 +181,20 @@ Sie kรถnnen beispielsweise einen zusรคtzlichen Medientyp `image/png` hinzufรผgen
{!../../../docs_src/additional_responses/tutorial002.py!}
```
!!! note "Hinweis"
/// note | "Hinweis"
Beachten Sie, dass Sie das Bild direkt mit einer `FileResponse` zurรผckgeben mรผssen.
!!! info
///
/// info
Sofern Sie in Ihrem Parameter `responses` nicht explizit einen anderen Medientyp angeben, geht FastAPI davon aus, dass die Response denselben Medientyp wie die Haupt-Response-Klasse hat (StandardmรครŸig `application/json`).
Wenn Sie jedoch eine benutzerdefinierte Response-Klasse mit `None` als Medientyp angegeben haben, verwendet FastAPI `application/json` fรผr jede zusรคtzliche Response, die รผber ein zugehรถriges Modell verfรผgt.
///
## Informationen kombinieren
Sie kรถnnen auch Response-Informationen von mehreren Stellen kombinieren, einschlieรŸlich der Parameter `response_model`, `status_code` und `responses`.

40
docs/de/docs/advanced/additional-status-codes.md

@ -14,54 +14,76 @@ Sie mรถchten aber auch, dass sie neue Artikel akzeptiert. Und wenn die Elemente
Um dies zu erreichen, importieren Sie `JSONResponse`, und geben Sie Ihren Inhalt direkt zurรผck, indem Sie den gewรผnschten `status_code` setzen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="4 25"
{!> ../../../docs_src/additional_status_codes/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="4 25"
{!> ../../../docs_src/additional_status_codes/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4 26"
{!> ../../../docs_src/additional_status_codes/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="2 23"
{!> ../../../docs_src/additional_status_codes/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="4 25"
{!> ../../../docs_src/additional_status_codes/tutorial001.py!}
```
!!! warning "Achtung"
////
/// warning | "Achtung"
Wenn Sie eine `Response` direkt zurรผckgeben, wie im obigen Beispiel, wird sie direkt zurรผckgegeben.
Sie wird nicht mit einem Modell usw. serialisiert.
Stellen Sie sicher, dass sie die gewรผnschten Daten enthรคlt und dass die Werte gรผltiges JSON sind (wenn Sie `JSONResponse` verwenden).
!!! note "Technische Details"
///
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import JSONResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette. Das Gleiche gilt fรผr `status`.
///
## OpenAPI- und API-Dokumentation
Wenn Sie zusรคtzliche Statuscodes und Responses direkt zurรผckgeben, werden diese nicht in das OpenAPI-Schema (die API-Dokumentation) aufgenommen, da FastAPI keine Mรถglichkeit hat, im Voraus zu wissen, was Sie zurรผckgeben werden.

73
docs/de/docs/advanced/advanced-dependencies.md

@ -18,81 +18,108 @@ Nicht die Klasse selbst (die bereits aufrufbar ist), sondern eine Instanz dieser
Dazu deklarieren wir eine Methode `__call__`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="12"
{!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="11"
{!> ../../../docs_src/dependencies/tutorial011_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10"
{!> ../../../docs_src/dependencies/tutorial011.py!}
```
////
In diesem Fall ist dieses `__call__` das, was **FastAPI** verwendet, um nach zusรคtzlichen Parametern und Unterabhรคngigkeiten zu suchen, und das ist es auch, was spรคter aufgerufen wird, um einen Wert an den Parameter in Ihrer *Pfadoperation-Funktion* zu รผbergeben.
## Die Instanz parametrisieren
Und jetzt kรถnnen wir `__init__` verwenden, um die Parameter der Instanz zu deklarieren, die wir zum `Parametrisieren` der Abhรคngigkeit verwenden kรถnnen:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8"
{!> ../../../docs_src/dependencies/tutorial011_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/dependencies/tutorial011.py!}
```
////
In diesem Fall wird **FastAPI** `__init__` nie berรผhren oder sich darum kรผmmern, wir werden es direkt in unserem Code verwenden.
## Eine Instanz erstellen
Wir kรถnnten eine Instanz dieser Klasse erstellen mit:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="18"
{!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17"
{!> ../../../docs_src/dependencies/tutorial011_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="16"
{!> ../../../docs_src/dependencies/tutorial011.py!}
```
////
Und auf diese Weise kรถnnen wir unsere Abhรคngigkeit โ€žparametrisierenโ€œ, die jetzt `"bar"` enthรคlt, als das Attribut `checker.fixed_content`.
## Die Instanz als Abhรคngigkeit verwenden
@ -107,28 +134,38 @@ checker(q="somequery")
... und รผbergibt, was immer das als Wert dieser Abhรคngigkeit in unserer *Pfadoperation-Funktion* zurรผckgibt, als den Parameter `fixed_content_included`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="22"
{!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="21"
{!> ../../../docs_src/dependencies/tutorial011_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="20"
{!> ../../../docs_src/dependencies/tutorial011.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Das alles mag gekรผnstelt wirken. Und es ist mรถglicherweise noch nicht ganz klar, welchen Nutzen das hat.
Diese Beispiele sind bewusst einfach gehalten, zeigen aber, wie alles funktioniert.
@ -136,3 +173,5 @@ checker(q="somequery")
In den Kapiteln zum Thema Sicherheit gibt es Hilfsfunktionen, die auf die gleiche Weise implementiert werden.
Wenn Sie das hier alles verstanden haben, wissen Sie bereits, wie diese Sicherheits-Hilfswerkzeuge unter der Haube funktionieren.
///

20
docs/de/docs/advanced/async-tests.md

@ -64,9 +64,12 @@ Der Marker `@pytest.mark.anyio` teilt pytest mit, dass diese Testfunktion asynch
{!../../../docs_src/async_tests/test_main.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass die Testfunktion jetzt `async def` ist und nicht nur `def` wie zuvor, wenn Sie den `TestClient` verwenden.
///
Dann kรถnnen wir einen `AsyncClient` mit der App erstellen und mit `await` asynchrone Requests an ihn senden.
```Python hl_lines="9-10"
@ -81,15 +84,24 @@ response = client.get('/')
... welches wir verwendet haben, um unsere Requests mit dem `TestClient` zu machen.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass wir async/await mit dem neuen `AsyncClient` verwenden โ€“ der Request ist asynchron.
!!! warning "Achtung"
///
/// warning | "Achtung"
Falls Ihre Anwendung auf Lifespan-Events angewiesen ist, der `AsyncClient` lรถst diese Events nicht aus. Um sicherzustellen, dass sie ausgelรถst werden, verwenden Sie `LifespanManager` von <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a>.
///
## Andere asynchrone Funktionsaufrufe
Da die Testfunktion jetzt asynchron ist, kรถnnen Sie in Ihren Tests neben dem Senden von Requests an Ihre FastAPI-Anwendung jetzt auch andere `async`hrone Funktionen aufrufen (und `await`en), genau so, wie Sie diese an anderer Stelle in Ihrem Code aufrufen wรผrden.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie einen `RuntimeError: Task attached to a different loop` erhalten, wenn Sie asynchrone Funktionsaufrufe in Ihre Tests integrieren (z. B. bei Verwendung von <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MongoDBs MotorClient</a>), dann denken Sie daran, Objekte zu instanziieren, die einen Event Loop nur innerhalb asynchroner Funktionen benรถtigen, z. B. einen `@app.on_event("startup")`-Callback.
///

35
docs/de/docs/advanced/behind-a-proxy.md

@ -43,9 +43,12 @@ browser --> proxy
proxy --> server
```
!!! tip "Tipp"
/// tip | "Tipp"
Die IP `0.0.0.0` wird รผblicherweise verwendet, um anzudeuten, dass das Programm alle auf diesem Computer/Server verfรผgbaren IPs abhรถrt.
///
Die Benutzeroberflรคche der Dokumentation wรผrde benรถtigen, dass das OpenAPI-Schema deklariert, dass sich dieser API-`server` unter `/api/v1` (hinter dem Proxy) befindet. Zum Beispiel:
```JSON hl_lines="4-8"
@ -81,11 +84,14 @@ $ uvicorn main:app --root-path /api/v1
Falls Sie Hypercorn verwenden, das hat auch die Option `--root-path`.
!!! note "Technische Details"
/// note | "Technische Details"
Die ASGI-Spezifikation definiert einen `root_path` fรผr diesen Anwendungsfall.
Und die Kommandozeilenoption `--root-path` stellt diesen `root_path` bereit.
///
### รœberprรผfen des aktuellen `root_path`
Sie kรถnnen den aktuellen `root_path` abrufen, der von Ihrer Anwendung fรผr jede Anfrage verwendet wird. Er ist Teil des `scope`-Dictionarys (das ist Teil der ASGI-Spezifikation).
@ -172,9 +178,12 @@ Dann erstellen Sie eine Datei `traefik.toml` mit:
Dadurch wird Traefik angewiesen, Port 9999 abzuhรถren und eine andere Datei `routes.toml` zu verwenden.
!!! tip "Tipp"
/// tip | "Tipp"
Wir verwenden Port 9999 anstelle des Standard-HTTP-Ports 80, damit Sie ihn nicht mit Administratorrechten (`sudo`) ausfรผhren mรผssen.
///
Erstellen Sie nun die andere Datei `routes.toml`:
```TOML hl_lines="5 12 20"
@ -239,9 +248,12 @@ Wenn Sie nun zur URL mit dem Port fรผr Uvicorn gehen: <a href="http://127.0.0.1:
}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass, obwohl Sie unter `http://127.0.0.1:8000/app` darauf zugreifen, als `root_path` angezeigt wird `/api/v1`, welches aus der Option `--root-path` stammt.
///
ร–ffnen Sie nun die URL mit dem Port fรผr Traefik, einschlieรŸlich des Pfadprรคfixes: <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/app</a>.
Wir bekommen die gleiche Response:
@ -283,9 +295,12 @@ Dies liegt daran, dass FastAPI diesen `root_path` verwendet, um den Default-`ser
## Zusรคtzliche Server
!!! warning "Achtung"
/// warning | "Achtung"
Dies ist ein fortgeschrittener Anwendungsfall. รœberspringen Sie das gerne.
///
StandardmรครŸig erstellt **FastAPI** einen `server` im OpenAPI-Schema mit der URL fรผr den `root_path`.
Sie kรถnnen aber auch andere alternative `server` bereitstellen, beispielsweise wenn Sie mรถchten, dass *dieselbe* Dokumentationsoberflรคche mit einer Staging- und Produktionsumgebung interagiert.
@ -323,16 +338,22 @@ Erzeugt ein OpenAPI-Schema, wie:
}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie den automatisch generierten Server mit dem `URL`-Wert `/api/v1`, welcher vom `root_path` stammt.
///
In der Dokumentationsoberflรคche unter <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a> wรผrde es so aussehen:
<img src="/img/tutorial/behind-a-proxy/image03.png">
!!! tip "Tipp"
/// tip | "Tipp"
Die Dokumentationsoberflรคche interagiert mit dem von Ihnen ausgewรคhlten Server.
///
### Den automatischen Server von `root_path` deaktivieren
Wenn Sie nicht mรถchten, dass **FastAPI** einen automatischen Server inkludiert, welcher `root_path` verwendet, kรถnnen Sie den Parameter `root_path_in_servers=False` verwenden:

55
docs/de/docs/advanced/custom-response.md

@ -12,9 +12,12 @@ Der Inhalt, den Sie von Ihrer *Pfadoperation-Funktion* zurรผckgeben, wird in die
Und wenn diese `Response` einen JSON-Medientyp (`application/json`) hat, wie es bei `JSONResponse` und `UJSONResponse` der Fall ist, werden die von Ihnen zurรผckgegebenen Daten automatisch mit jedem Pydantic `response_model` konvertiert (und gefiltert), das Sie im *Pfadoperation-Dekorator* deklariert haben.
!!! note "Hinweis"
/// note | "Hinweis"
Wenn Sie eine Response-Klasse ohne Medientyp verwenden, erwartet FastAPI, dass Ihre Response keinen Inhalt hat, und dokumentiert daher das Format der Response nicht in deren generierter OpenAPI-Dokumentation.
///
## `ORJSONResponse` verwenden
Um beispielsweise noch etwas Leistung herauszuholen, kรถnnen Sie <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> installieren und verwenden, und die Response als `ORJSONResponse` deklarieren.
@ -31,16 +34,22 @@ Wenn Sie jedoch sicher sind, dass der von Ihnen zurรผckgegebene Inhalt **mit JSO
{!../../../docs_src/custom_response/tutorial001b.py!}
```
!!! info
/// info
Der Parameter `response_class` wird auch verwendet, um den โ€žMedientypโ€œ der Response zu definieren.
In diesem Fall wird der HTTP-Header `Content-Type` auf `application/json` gesetzt.
Und er wird als solcher in OpenAPI dokumentiert.
!!! tip "Tipp"
///
/// tip | "Tipp"
Die `ORJSONResponse` ist derzeit nur in FastAPI verfรผgbar, nicht in Starlette.
///
## HTML-Response
Um eine Response mit HTML direkt von **FastAPI** zurรผckzugeben, verwenden Sie `HTMLResponse`.
@ -52,13 +61,16 @@ Um eine Response mit HTML direkt von **FastAPI** zurรผckzugeben, verwenden Sie `
{!../../../docs_src/custom_response/tutorial002.py!}
```
!!! info
/// info
Der Parameter `response_class` wird auch verwendet, um den โ€žMedientypโ€œ der Response zu definieren.
In diesem Fall wird der HTTP-Header `Content-Type` auf `text/html` gesetzt.
Und er wird als solcher in OpenAPI dokumentiert.
///
### Eine `Response` zurรผckgeben
Wie in [Eine Response direkt zurรผckgeben](response-directly.md){.internal-link target=_blank} gezeigt, kรถnnen Sie die Response auch direkt in Ihrer *Pfadoperation* รผberschreiben, indem Sie diese zurรผckgeben.
@ -69,12 +81,18 @@ Das gleiche Beispiel von oben, das eine `HTMLResponse` zurรผckgibt, kรถnnte so a
{!../../../docs_src/custom_response/tutorial003.py!}
```
!!! warning "Achtung"
/// warning | "Achtung"
Eine `Response`, die direkt von Ihrer *Pfadoperation-Funktion* zurรผckgegeben wird, wird in OpenAPI nicht dokumentiert (zum Beispiel wird der `Content-Type` nicht dokumentiert) und ist in der automatischen interaktiven Dokumentation nicht sichtbar.
!!! info
///
/// info
Natรผrlich stammen der eigentliche `Content-Type`-Header, der Statuscode, usw., aus dem `Response`-Objekt, das Sie zurรผckgegeben haben.
///
### In OpenAPI dokumentieren und `Response` รผberschreiben
Wenn Sie die Response innerhalb der Funktion รผberschreiben und gleichzeitig den โ€žMedientypโ€œ in OpenAPI dokumentieren mรถchten, kรถnnen Sie den `response_class`-Parameter verwenden UND ein `Response`-Objekt zurรผckgeben.
@ -103,11 +121,14 @@ Hier sind einige der verfรผgbaren Responses.
Bedenken Sie, dass Sie `Response` verwenden kรถnnen, um alles andere zurรผckzugeben, oder sogar eine benutzerdefinierte Unterklasse zu erstellen.
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import HTMLResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette.
///
### `Response`
Die Hauptklasse `Response`, alle anderen Responses erben von ihr.
@ -153,16 +174,22 @@ Eine schnelle alternative JSON-Response mit <a href="https://github.com/ijl/orjs
Eine alternative JSON-Response mit <a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a>.
!!! warning "Achtung"
/// warning | "Achtung"
`ujson` ist bei der Behandlung einiger Sonderfรคlle weniger sorgfรคltig als Pythons eingebaute Implementierung.
///
```Python hl_lines="2 7"
{!../../../docs_src/custom_response/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Mรถglicherweise ist `ORJSONResponse` eine schnellere Alternative.
///
### `RedirectResponse`
Gibt eine HTTP-Weiterleitung (HTTP-Redirect) zurรผck. Verwendet standardmรครŸig den Statuscode 307 โ€“ Temporรคre Weiterleitung (Temporary Redirect).
@ -222,9 +249,12 @@ Das umfasst viele Bibliotheken zur Interaktion mit Cloud-Speicher, Videoverarbei
Auf diese Weise kรถnnen wir das Ganze in einen `with`-Block einfรผgen und so sicherstellen, dass das dateiartige Objekt nach Abschluss geschlossen wird.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass wir, da wir Standard-`open()` verwenden, welches `async` und `await` nicht unterstรผtzt, hier die Pfadoperation mit normalen `def` deklarieren.
///
### `FileResponse`
Streamt eine Datei asynchron als Response.
@ -292,9 +322,12 @@ Im folgenden Beispiel verwendet **FastAPI** standardmรครŸig `ORJSONResponse` in
{!../../../docs_src/custom_response/tutorial010.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen dennoch weiterhin `response_class` in *Pfadoperationen* รผberschreiben, wie bisher.
///
## Zusรคtzliche Dokumentation
Sie kรถnnen auch den Medientyp und viele andere Details in OpenAPI mit `responses` deklarieren: [Zusรคtzliche Responses in OpenAPI](additional-responses.md){.internal-link target=_blank}.

5
docs/de/docs/advanced/dataclasses.md

@ -20,13 +20,16 @@ Und natรผrlich wird das gleiche unterstรผtzt:
Das funktioniert genauso wie mit Pydantic-Modellen. Und tatsรคchlich wird es unter der Haube mittels Pydantic auf die gleiche Weise bewerkstelligt.
!!! info
/// info
Bedenken Sie, dass Datenklassen nicht alles kรถnnen, was Pydantic-Modelle kรถnnen.
Daher mรผssen Sie mรถglicherweise weiterhin Pydantic-Modelle verwenden.
Wenn Sie jedoch eine Menge Datenklassen herumliegen haben, ist dies ein guter Trick, um sie fรผr eine Web-API mithilfe von FastAPI zu verwenden. ๐Ÿค“
///
## Datenklassen als `response_model`
Sie kรถnnen `dataclasses` auch im Parameter `response_model` verwenden:

25
docs/de/docs/advanced/events.md

@ -38,11 +38,14 @@ Hier simulieren wir das langsame *Hochfahren*, das Laden des Modells, indem wir
Und dann, direkt nach dem `yield`, entladen wir das Modell. Dieser Code wird unmittelbar vor dem *Herunterfahren* ausgefรผhrt, **nachdem** die Anwendung **die Bearbeitung von Requests abgeschlossen hat**. Dadurch kรถnnten beispielsweise Ressourcen wie Arbeitsspeicher oder eine GPU freigegeben werden.
!!! tip "Tipp"
/// tip | "Tipp"
Das *Herunterfahren* wรผrde erfolgen, wenn Sie die Anwendung **stoppen**.
Mรถglicherweise mรผssen Sie eine neue Version starten, oder Sie haben es einfach satt, sie auszufรผhren. ๐Ÿคท
///
### Lifespan-Funktion
Das Erste, was auffรคllt, ist, dass wir eine asynchrone Funktion mit `yield` definieren. Das ist sehr รคhnlich zu Abhรคngigkeiten mit `yield`.
@ -91,11 +94,14 @@ Der Parameter `lifespan` der `FastAPI`-App benรถtigt einen **asynchronen Kontext
## Alternative Events (deprecated)
!!! warning "Achtung"
/// warning | "Achtung"
Der empfohlene Weg, das *Hochfahren* und *Herunterfahren* zu handhaben, ist die Verwendung des `lifespan`-Parameters der `FastAPI`-App, wie oben beschrieben. Wenn Sie einen `lifespan`-Parameter รผbergeben, werden die `startup`- und `shutdown`-Eventhandler nicht mehr aufgerufen. Es ist entweder alles `lifespan` oder alles Events, nicht beides.
Sie kรถnnen diesen Teil wahrscheinlich รผberspringen.
///
Es gibt eine alternative Mรถglichkeit, diese Logik zu definieren, sodass sie beim *Hochfahren* und beim *Herunterfahren* ausgefรผhrt wird.
Sie kรถnnen <abbr title="Eventhandler โ€“ Ereignisbehandler: Funktion, die bei jedem Eintreten eines bestimmten Ereignisses ausgefรผhrt wird">Eventhandler</abbr> (Funktionen) definieren, die ausgefรผhrt werden sollen, bevor die Anwendung hochgefahren wird oder wenn die Anwendung heruntergefahren wird.
@ -126,10 +132,14 @@ Um eine Funktion hinzuzufรผgen, die beim Herunterfahren der Anwendung ausgefรผhr
Hier schreibt die `shutdown`-Eventhandler-Funktion eine Textzeile `"Application shutdown"` in eine Datei `log.txt`.
!!! info
/// info
In der Funktion `open()` bedeutet `mode="a"` โ€žappendโ€œ (โ€žanhรคngenโ€œ), sodass die Zeile nach dem, was sich in dieser Datei befindet, hinzugefรผgt wird, ohne den vorherigen Inhalt zu รผberschreiben.
!!! tip "Tipp"
///
/// tip | "Tipp"
Beachten Sie, dass wir in diesem Fall eine Standard-Python-Funktion `open()` verwenden, die mit einer Datei interagiert.
Es handelt sich also um I/O (Input/Output), welches โ€žWartenโ€œ erfordert, bis Dinge auf die Festplatte geschrieben werden.
@ -138,6 +148,8 @@ Hier schreibt die `shutdown`-Eventhandler-Funktion eine Textzeile `"Application
Daher deklarieren wir die Eventhandler-Funktion mit Standard-`def` statt mit `async def`.
///
### `startup` und `shutdown` zusammen
Es besteht eine hohe Wahrscheinlichkeit, dass die Logik fรผr Ihr *Hochfahren* und *Herunterfahren* miteinander verknรผpft ist. Vielleicht mรถchten Sie etwas beginnen und es dann beenden, eine Ressource laden und sie dann freigeben usw.
@ -152,11 +164,14 @@ Nur ein technisches Detail fรผr die neugierigen Nerds. ๐Ÿค“
In der technischen ASGI-Spezifikation ist dies Teil des <a href="https://asgi.readthedocs.io/en/latest/specs/lifespan.html" class="external-link" target="_blank">Lifespan Protokolls</a> und definiert Events namens `startup` und `shutdown`.
!!! info
/// info
Weitere Informationen zu Starlettes `lifespan`-Handlern finden Sie in <a href="https://www.starlette.io/lifespan/" class="external-link" target="_blank">Starlettes Lifespan-Dokumentation</a>.
EinschlieรŸlich, wie man Lifespan-Zustand handhabt, der in anderen Bereichen Ihres Codes verwendet werden kann.
///
## Unteranwendungen
๐Ÿšจ Beachten Sie, dass diese Lifespan-Events (Hochfahren und Herunterfahren) nur fรผr die Hauptanwendung ausgefรผhrt werden, nicht fรผr [Unteranwendungen โ€“ Mounts](sub-applications.md){.internal-link target=_blank}.

37
docs/de/docs/advanced/generate-clients.md

@ -28,18 +28,22 @@ Es gibt auch mehrere andere Unternehmen, welche รคhnliche Dienste anbieten und d
Beginnen wir mit einer einfachen FastAPI-Anwendung:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="7-9 12-13 16-17 21"
{!> ../../../docs_src/generate_clients/tutorial001_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9-11 14-15 18 19 23"
{!> ../../../docs_src/generate_clients/tutorial001.py!}
```
////
Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, welche diese fรผr die Request- und Response-<abbr title="Die eigentlichen Nutzdaten, abzรผglich der Metadaten">Payload</abbr> verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden.
### API-Dokumentation
@ -123,9 +127,12 @@ Sie erhalten auรŸerdem automatische Vervollstรคndigung fรผr die zu sendende Payl
<img src="/img/tutorial/generate-clients/image03.png">
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie die automatische Vervollstรคndigung fรผr `name` und `price`, welche in der FastAPI-Anwendung im `Item`-Modell definiert wurden.
///
Sie erhalten Inline-Fehlerberichte fรผr die von Ihnen gesendeten Daten:
<img src="/img/tutorial/generate-clients/image04.png">
@ -140,18 +147,22 @@ In vielen Fรคllen wird Ihre FastAPI-Anwendung grรถรŸer sein und Sie werden wahrs
Beispielsweise kรถnnten Sie einen Abschnitt fรผr **Items (Artikel)** und einen weiteren Abschnitt fรผr **Users (Benutzer)** haben, und diese kรถnnten durch Tags getrennt sein:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="21 26 34"
{!> ../../../docs_src/generate_clients/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="23 28 36"
{!> ../../../docs_src/generate_clients/tutorial002.py!}
```
////
### Einen TypeScript-Client mit Tags generieren
Wenn Sie unter Verwendung von Tags einen Client fรผr eine FastAPI-Anwendung generieren, wird normalerweise auch der Client-Code anhand der Tags getrennt.
@ -197,18 +208,22 @@ Hier verwendet sie beispielsweise den ersten Tag (Sie werden wahrscheinlich nur
AnschlieรŸend kรถnnen Sie diese benutzerdefinierte Funktion als Parameter `generate_unique_id_function` an **FastAPI** รผbergeben:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="6-7 10"
{!> ../../../docs_src/generate_clients/tutorial003_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8-9 12"
{!> ../../../docs_src/generate_clients/tutorial003.py!}
```
////
### Einen TypeScript-Client mit benutzerdefinierten Operation-IDs generieren
Wenn Sie nun den Client erneut generieren, werden Sie feststellen, dass er รผber die verbesserten Methodennamen verfรผgt:
@ -229,18 +244,22 @@ Aber fรผr den generierten Client kรถnnten wir die OpenAPI-Operation-IDs direkt v
Wir kรถnnten das OpenAPI-JSON in eine Datei `openapi.json` herunterladen und dann mit einem Skript wie dem folgenden **den vorangestellten Tag entfernen**:
=== "Python"
//// tab | Python
```Python
{!> ../../../docs_src/generate_clients/tutorial004.py!}
```
=== "Node.js"
////
//// tab | Node.js
```Javascript
{!> ../../../docs_src/generate_clients/tutorial004.js!}
```
////
Damit wรผrden die Operation-IDs von Dingen wie `items-get_items` in `get_items` umbenannt, sodass der Client-Generator einfachere Methodennamen generieren kann.
### Einen TypeScript-Client mit der modifizierten OpenAPI generieren

5
docs/de/docs/advanced/index.md

@ -6,11 +6,14 @@ Das Haupt-[Tutorial โ€“ Benutzerhandbuch](../tutorial/index.md){.internal-link t
In den nรคchsten Abschnitten sehen Sie weitere Optionen, Konfigurationen und zusรคtzliche Funktionen.
!!! tip "Tipp"
/// tip | "Tipp"
Die nรคchsten Abschnitte sind **nicht unbedingt โ€žfortgeschrittenโ€œ**.
Und es ist mรถglich, dass fรผr Ihren Anwendungsfall die Lรถsung in einem davon liegt.
///
## Lesen Sie zuerst das Tutorial
Sie kรถnnen immer noch die meisten Funktionen in **FastAPI** mit den Kenntnissen aus dem Haupt-[Tutorial โ€“ Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} nutzen.

5
docs/de/docs/advanced/middleware.md

@ -43,11 +43,14 @@ app.add_middleware(UnicornMiddleware, some_config="rainbow")
**FastAPI** enthรคlt mehrere Middlewares fรผr gรคngige Anwendungsfรคlle. Wir werden als Nรคchstes sehen, wie man sie verwendet.
!!! note "Technische Details"
/// note | "Technische Details"
Fรผr die nรคchsten Beispiele kรถnnten Sie auch `from starlette.middleware.something import SomethingMiddleware` verwenden.
**FastAPI** bietet mehrere Middlewares via `fastapi.middleware` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Middlewares kommen aber direkt von Starlette.
///
## `HTTPSRedirectMiddleware`
Erzwingt, dass alle eingehenden Requests entweder `https` oder `wss` sein mรผssen.

25
docs/de/docs/advanced/openapi-callbacks.md

@ -35,9 +35,12 @@ Dieser Teil ist ziemlich normal, der grรถรŸte Teil des Codes ist Ihnen wahrschei
{!../../../docs_src/openapi_callbacks/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Der Query-Parameter `callback_url` verwendet einen Pydantic-<a href="https://docs.pydantic.dev/latest/api/networks/" class="external-link" target="_blank">Url</a>-Typ.
///
Das einzig Neue ist `callbacks=invoices_callback_router.routes` als Argument fรผr den *Pfadoperation-Dekorator*. Wir werden als Nรคchstes sehen, was das ist.
## Dokumentation des Callbacks
@ -61,11 +64,14 @@ Diese Dokumentation wird in der Swagger-Oberflรคche unter `/docs` in Ihrer API a
In diesem Beispiel wird nicht der Callback selbst implementiert (das kรถnnte nur eine Codezeile sein), sondern nur der Dokumentationsteil.
!!! tip "Tipp"
/// tip | "Tipp"
Der eigentliche Callback ist nur ein HTTP-Request.
Wenn Sie den Callback selbst implementieren, kรถnnen Sie beispielsweise <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> oder <a href="https://requests.readthedocs.io/" class="external-link" target="_blank">Requests</a> verwenden.
///
## Schreiben des Codes, der den Callback dokumentiert
Dieser Code wird nicht in Ihrer Anwendung ausgefรผhrt, wir benรถtigen ihn nur, um zu *dokumentieren*, wie diese *externe API* aussehen soll.
@ -74,11 +80,14 @@ Sie wissen jedoch bereits, wie Sie mit **FastAPI** ganz einfach eine automatisch
Daher werden wir dasselbe Wissen nutzen, um zu dokumentieren, wie die *externe API* aussehen sollte ... indem wir die *Pfadoperation(en)* erstellen, welche die externe API implementieren soll (die, welche Ihre API aufruft).
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie den Code zum Dokumentieren eines Callbacks schreiben, kann es hilfreich sein, sich vorzustellen, dass Sie dieser *externe Entwickler* sind. Und dass Sie derzeit die *externe API* implementieren, nicht *Ihre API*.
Wenn Sie diese Sichtweise (des *externen Entwicklers*) vorรผbergehend รผbernehmen, wird es offensichtlicher, wo die Parameter, das Pydantic-Modell fรผr den Body, die Response, usw. fรผr diese *externe API* hingehรถren.
///
### Einen Callback-`APIRouter` erstellen
Erstellen Sie zunรคchst einen neuen `APIRouter`, der einen oder mehrere Callbacks enthรคlt.
@ -154,9 +163,12 @@ und sie wรผrde eine Response von dieser *externen API* mit einem JSON-Body wie d
}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass die verwendete Callback-URL die URL enthรคlt, die als Query-Parameter in `callback_url` (`https://www.external.org/events`) empfangen wurde, und auch die Rechnungs-`id` aus dem JSON-Body (`2expen51ve`).
///
### Den Callback-Router hinzufรผgen
An diesem Punkt haben Sie die benรถtigte(n) *Callback-Pfadoperation(en)* (diejenige(n), die der *externe Entwickler* in der *externen API* implementieren sollte) im Callback-Router, den Sie oben erstellt haben.
@ -167,9 +179,12 @@ Verwenden Sie nun den Parameter `callbacks` im *Pfadoperation-Dekorator Ihrer AP
{!../../../docs_src/openapi_callbacks/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass Sie nicht den Router selbst (`invoices_callback_router`) an `callback=` รผbergeben, sondern das Attribut `.routes`, wie in `invoices_callback_router.routes`.
///
### Es in der Dokumentation ansehen
Jetzt kรถnnen Sie Ihre Anwendung mit Uvicorn starten und auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> gehen.

10
docs/de/docs/advanced/openapi-webhooks.md

@ -22,9 +22,12 @@ Mit **FastAPI** kรถnnen Sie mithilfe von OpenAPI die Namen dieser Webhooks, die
Dies kann es Ihren Benutzern viel einfacher machen, **deren APIs zu implementieren**, um Ihre **Webhook**-Requests zu empfangen. Mรถglicherweise kรถnnen diese sogar einen Teil des eigenem API-Codes automatisch generieren.
!!! info
/// info
Webhooks sind in OpenAPI 3.1.0 und hรถher verfรผgbar und werden von FastAPI `0.99.0` und hรถher unterstรผtzt.
///
## Eine Anwendung mit Webhooks
Wenn Sie eine **FastAPI**-Anwendung erstellen, gibt es ein `webhooks`-Attribut, mit dem Sie *Webhooks* definieren kรถnnen, genauso wie Sie *Pfadoperationen* definieren wรผrden, zum Beispiel mit `@app.webhooks.post()`.
@ -35,9 +38,12 @@ Wenn Sie eine **FastAPI**-Anwendung erstellen, gibt es ein `webhooks`-Attribut,
Die von Ihnen definierten Webhooks landen im **OpenAPI**-Schema und der automatischen **Dokumentations-Oberflรคche**.
!!! info
/// info
Das `app.webhooks`-Objekt ist eigentlich nur ein `APIRouter`, derselbe Typ, den Sie verwenden wรผrden, wenn Sie Ihre Anwendung mit mehreren Dateien strukturieren.
///
Beachten Sie, dass Sie bei Webhooks tatsรคchlich keinen *Pfad* (wie `/items/`) deklarieren, sondern dass der Text, den Sie dort รผbergeben, lediglich eine **Kennzeichnung** des Webhooks (der Name des Events) ist. Zum Beispiel ist in `@app.webhooks.post("new-subscription")` der Webhook-Name `new-subscription`.
Das liegt daran, dass erwartet wird, dass **Ihre Benutzer** den tatsรคchlichen **URL-Pfad**, an dem diese den Webhook-Request empfangen mรถchten, auf andere Weise definieren (z. B. รผber ein Web-Dashboard).

56
docs/de/docs/advanced/path-operation-advanced-configuration.md

@ -2,9 +2,12 @@
## OpenAPI operationId
!!! warning "Achtung"
/// warning | "Achtung"
Wenn Sie kein โ€žExperteโ€œ fรผr OpenAPI sind, brauchen Sie dies wahrscheinlich nicht.
///
Mit dem Parameter `operation_id` kรถnnen Sie die OpenAPI `operationId` festlegen, die in Ihrer *Pfadoperation* verwendet werden soll.
Sie mรผssten sicherstellen, dass sie fรผr jede Operation eindeutig ist.
@ -23,14 +26,20 @@ Sie sollten dies tun, nachdem Sie alle Ihre *Pfadoperationen* hinzugefรผgt haben
{!../../../docs_src/path_operation_advanced_configuration/tutorial002.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie `app.openapi()` manuell aufrufen, sollten Sie vorher die `operationId`s aktualisiert haben.
!!! warning "Achtung"
///
/// warning | "Achtung"
Wenn Sie dies tun, mรผssen Sie sicherstellen, dass jede Ihrer *Pfadoperation-Funktionen* einen eindeutigen Namen hat.
Auch wenn diese sich in unterschiedlichen Modulen (Python-Dateien) befinden.
///
## Von OpenAPI ausschlieรŸen
Um eine *Pfadoperation* aus dem generierten OpenAPI-Schema (und damit aus den automatischen Dokumentationssystemen) auszuschlieรŸen, verwenden Sie den Parameter `include_in_schema` und setzen Sie ihn auf `False`:
@ -65,20 +74,26 @@ Es gibt hier in der Dokumentation ein ganzes Kapitel darรผber, Sie kรถnnen es un
Wenn Sie in Ihrer Anwendung eine *Pfadoperation* deklarieren, generiert **FastAPI** automatisch die relevanten Metadaten dieser *Pfadoperation*, die in das OpenAPI-Schema aufgenommen werden sollen.
!!! note "Technische Details"
/// note | "Technische Details"
In der OpenAPI-Spezifikation wird das <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">Operationsobjekt</a> genannt.
///
Es hat alle Informationen zur *Pfadoperation* und wird zur Erstellung der automatischen Dokumentation verwendet.
Es enthรคlt `tags`, `parameters`, `requestBody`, `responses`, usw.
Dieses *Pfadoperation*-spezifische OpenAPI-Schema wird normalerweise automatisch von **FastAPI** generiert, Sie kรถnnen es aber auch erweitern.
!!! tip "Tipp"
/// tip | "Tipp"
Dies ist ein Low-Level Erweiterungspunkt.
Wenn Sie nur zusรคtzliche Responses deklarieren mรผssen, kรถnnen Sie dies bequemer mit [Zusรคtzliche Responses in OpenAPI](additional-responses.md){.internal-link target=_blank} tun.
///
Sie kรถnnen das OpenAPI-Schema fรผr eine *Pfadoperation* erweitern, indem Sie den Parameter `openapi_extra` verwenden.
### OpenAPI-Erweiterungen
@ -150,43 +165,60 @@ Und Sie kรถnnten dies auch tun, wenn der Datentyp in der Anfrage nicht JSON ist.
In der folgenden Anwendung verwenden wir beispielsweise weder die integrierte Funktionalitรคt von FastAPI zum Extrahieren des JSON-Schemas aus Pydantic-Modellen noch die automatische Validierung fรผr JSON. Tatsรคchlich deklarieren wir den Request-Content-Type als YAML und nicht als JSON:
=== "Pydantic v2"
//// tab | Pydantic v2
```Python hl_lines="17-22 24"
{!> ../../../docs_src/path_operation_advanced_configuration/tutorial007.py!}
```
=== "Pydantic v1"
////
//// tab | Pydantic v1
```Python hl_lines="17-22 24"
{!> ../../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py!}
```
!!! info
////
/// info
In Pydantic Version 1 hieรŸ die Methode zum Abrufen des JSON-Schemas fรผr ein Modell `Item.schema()`, in Pydantic Version 2 heiรŸt die Methode `Item.model_json_schema()`.
///
Obwohl wir nicht die standardmรครŸig integrierte Funktionalitรคt verwenden, verwenden wir dennoch ein Pydantic-Modell, um das JSON-Schema fรผr die Daten, die wir in YAML empfangen mรถchten, manuell zu generieren.
Dann verwenden wir den Request direkt und extrahieren den Body als `bytes`. Das bedeutet, dass FastAPI nicht einmal versucht, den Request-Payload als JSON zu parsen.
Und dann parsen wir in unserem Code diesen YAML-Inhalt direkt und verwenden dann wieder dasselbe Pydantic-Modell, um den YAML-Inhalt zu validieren:
=== "Pydantic v2"
//// tab | Pydantic v2
```Python hl_lines="26-33"
{!> ../../../docs_src/path_operation_advanced_configuration/tutorial007.py!}
```
=== "Pydantic v1"
////
//// tab | Pydantic v1
```Python hl_lines="26-33"
{!> ../../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py!}
```
!!! info
////
/// info
In Pydantic Version 1 war die Methode zum Parsen und Validieren eines Objekts `Item.parse_obj()`, in Pydantic Version 2 heiรŸt die Methode `Item.model_validate()`.
!!! tip "Tipp"
///
/// tip | "Tipp"
Hier verwenden wir dasselbe Pydantic-Modell wieder.
Aber genauso hรคtten wir es auch auf andere Weise validieren kรถnnen.
///

10
docs/de/docs/advanced/response-cookies.md

@ -30,20 +30,26 @@ Setzen Sie dann Cookies darin und geben Sie sie dann zurรผck:
{!../../../docs_src/response_cookies/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass, wenn Sie eine Response direkt zurรผckgeben, anstatt den `Response`-Parameter zu verwenden, FastAPI diese direkt zurรผckgibt.
Sie mรผssen also sicherstellen, dass Ihre Daten vom richtigen Typ sind. Z. B. sollten diese mit JSON kompatibel sein, wenn Sie eine `JSONResponse` zurรผckgeben.
Und auch, dass Sie keine Daten senden, die durch ein `response_model` hรคtten gefiltert werden sollen.
///
### Mehr Informationen
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import Response` oder `from starlette.responses import JSONResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette.
Und da die `Response` hรคufig zum Setzen von Headern und Cookies verwendet wird, stellt **FastAPI** diese auch unter `fastapi.Response` bereit.
///
Um alle verfรผgbaren Parameter und Optionen anzuzeigen, sehen Sie sich deren <a href="https://www.starlette.io/responses/#set-cookie" class="external-link" target="_blank">Dokumentation in Starlette</a> an.

10
docs/de/docs/advanced/response-directly.md

@ -14,9 +14,12 @@ Das kann beispielsweise nรผtzlich sein, um benutzerdefinierte Header oder Cookie
Tatsรคchlich kรถnnen Sie jede `Response` oder jede Unterklasse davon zurรผckgeben.
!!! tip "Tipp"
/// tip | "Tipp"
`JSONResponse` selbst ist eine Unterklasse von `Response`.
///
Und wenn Sie eine `Response` zurรผckgeben, wird **FastAPI** diese direkt weiterleiten.
Es wird keine Datenkonvertierung mit Pydantic-Modellen durchfรผhren, es wird den Inhalt nicht in irgendeinen Typ konvertieren, usw.
@ -35,11 +38,14 @@ In diesen Fรคllen kรถnnen Sie den `jsonable_encoder` verwenden, um Ihre Daten zu
{!../../../docs_src/response_directly/tutorial001.py!}
```
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import JSONResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette.
///
## Eine benutzerdefinierte `Response` zurรผckgeben
Das obige Beispiel zeigt alle Teile, die Sie benรถtigen, ist aber noch nicht sehr nรผtzlich, da Sie das `item` einfach direkt hรคtten zurรผckgeben kรถnnen, und **FastAPI** wรผrde es fรผr Sie in eine `JSONResponse` einfรผgen, es in ein `dict` konvertieren, usw. All das standardmรครŸig.

5
docs/de/docs/advanced/response-headers.md

@ -28,13 +28,16 @@ Erstellen Sie eine Response wie in [Eine Response direkt zurรผckgeben](response-
{!../../../docs_src/response_headers/tutorial001.py!}
```
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import Response` oder `from starlette.responses import JSONResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette.
Und da die `Response` hรคufig zum Setzen von Headern und Cookies verwendet wird, stellt **FastAPI** diese auch unter `fastapi.Response` bereit.
///
## Benutzerdefinierte Header
Beachten Sie, dass benutzerdefinierte proprietรคre Header <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">mittels des Prรคfix 'X-'</a> hinzugefรผgt werden kรถnnen.

51
docs/de/docs/advanced/security/http-basic-auth.md

@ -20,27 +20,36 @@ Wenn Sie dann den Benutzernamen und das Passwort eingeben, sendet der Browser di
* Diese gibt ein Objekt vom Typ `HTTPBasicCredentials` zurรผck:
* Es enthรคlt den gesendeten `username` und das gesendete `password`.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="4 8 12"
{!> ../../../docs_src/security/tutorial006_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="2 7 11"
{!> ../../../docs_src/security/tutorial006_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="2 6 10"
{!> ../../../docs_src/security/tutorial006.py!}
```
////
Wenn Sie versuchen, die URL zum ersten Mal zu รถffnen (oder in der Dokumentation auf den Button โ€žExecuteโ€œ zu klicken), wird der Browser Sie nach Ihrem Benutzernamen und Passwort fragen:
<img src="/img/tutorial/security/image12.png">
@ -59,27 +68,36 @@ Um dies zu lรถsen, konvertieren wir zunรคchst den `username` und das `password`
Dann kรถnnen wir `secrets.compare_digest()` verwenden, um sicherzustellen, dass `credentials.username` `"stanleyjobson"` und `credentials.password` `"swordfish"` ist.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="1 12-24"
{!> ../../../docs_src/security/tutorial007_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 12-24"
{!> ../../../docs_src/security/tutorial007_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1 11-21"
{!> ../../../docs_src/security/tutorial007.py!}
```
////
Dies wรคre das gleiche wie:
```Python
@ -142,23 +160,32 @@ So ist Ihr Anwendungscode, dank der Verwendung von `secrets.compare_digest()`, v
Nachdem Sie festgestellt haben, dass die Anmeldeinformationen falsch sind, geben Sie eine `HTTPException` mit dem Statuscode 401 zurรผck (derselbe, der auch zurรผckgegeben wird, wenn keine Anmeldeinformationen angegeben werden) und fรผgen den Header `WWW-Authenticate` hinzu, damit der Browser die Anmeldeaufforderung erneut anzeigt:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="26-30"
{!> ../../../docs_src/security/tutorial007_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="26-30"
{!> ../../../docs_src/security/tutorial007_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="23-27"
{!> ../../../docs_src/security/tutorial007.py!}
```
////

5
docs/de/docs/advanced/security/index.md

@ -4,11 +4,14 @@
Neben den in [Tutorial โ€“ Benutzerhandbuch: Sicherheit](../../tutorial/security/index.md){.internal-link target=_blank} behandelten Funktionen gibt es noch einige zusรคtzliche Funktionen zur Handhabung der Sicherheit.
!!! tip "Tipp"
/// tip | "Tipp"
Die nรคchsten Abschnitte sind **nicht unbedingt โ€žfortgeschrittenโ€œ**.
Und es ist mรถglich, dass fรผr Ihren Anwendungsfall die Lรถsung in einem davon liegt.
///
## Lesen Sie zuerst das Tutorial
In den nรคchsten Abschnitten wird davon ausgegangen, dass Sie das Haupt-[Tutorial โ€“ Benutzerhandbuch: Sicherheit](../../tutorial/security/index.md){.internal-link target=_blank} bereits gelesen haben.

346
docs/de/docs/advanced/security/oauth2-scopes.md

@ -10,7 +10,8 @@ Jedes Mal, wenn Sie sich mit Facebook, Google, GitHub, Microsoft oder Twitter an
In diesem Abschnitt erfahren Sie, wie Sie Authentifizierung und Autorisierung mit demselben OAuth2, mit Scopes in Ihrer **FastAPI**-Anwendung verwalten.
!!! warning "Achtung"
/// warning | "Achtung"
Dies ist ein mehr oder weniger fortgeschrittener Abschnitt. Wenn Sie gerade erst anfangen, kรถnnen Sie ihn รผberspringen.
Sie benรถtigen nicht unbedingt OAuth2-Scopes, und Sie kรถnnen die Authentifizierung und Autorisierung handhaben wie Sie mรถchten.
@ -23,6 +24,8 @@ In diesem Abschnitt erfahren Sie, wie Sie Authentifizierung und Autorisierung mi
Aber wenn Sie wissen, dass Sie es brauchen oder neugierig sind, lesen Sie weiter.
///
## OAuth2-Scopes und OpenAPI
Die OAuth2-Spezifikation definiert โ€žScopesโ€œ als eine Liste von durch Leerzeichen getrennten Strings.
@ -43,7 +46,8 @@ Er wird normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu dekla
* `instagram_basic` wird von Facebook / Instagram verwendet.
* `https://www.googleapis.com/auth/drive` wird von Google verwendet.
!!! info
/// info
In OAuth2 ist ein โ€žScopeโ€œ nur ein String, der eine bestimmte erforderliche Berechtigung deklariert.
Es spielt keine Rolle, ob er andere Zeichen wie `:` enthรคlt oder ob es eine URL ist.
@ -52,55 +56,78 @@ Er wird normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu dekla
Fรผr OAuth2 sind es einfach nur Strings.
///
## Gesamtรผbersicht
Sehen wir uns zunรคchst kurz die Teile an, die sich gegenรผber den Beispielen im Haupt-**Tutorial โ€“ Benutzerhandbuch** fรผr [OAuth2 mit Password (und Hashing), Bearer mit JWT-Tokens](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank} รคndern. Diesmal verwenden wir OAuth2-Scopes:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="4 8 12 46 64 105 107-115 121-124 128-134 139 155"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="2 4 8 12 46 64 105 107-115 121-124 128-134 139 155"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="2 4 8 12 47 65 106 108-116 122-125 129-135 140 156"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3 7 11 45 63 104 106-114 120-123 127-133 138 154"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="2 4 8 12 46 64 105 107-115 121-124 128-134 139 155"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="2 4 8 12 46 64 105 107-115 121-124 128-134 139 155"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
Sehen wir uns diese ร„nderungen nun Schritt fรผr Schritt an.
## OAuth2-Sicherheitsschema
@ -109,52 +136,72 @@ Die erste ร„nderung ist, dass wir jetzt das OAuth2-Sicherheitsschema mit zwei ve
Der `scopes`-Parameter erhรคlt ein `dict` mit jedem Scope als Schlรผssel und dessen Beschreibung als Wert:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="62-65"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="62-65"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="63-66"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="61-64"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
////
=== "Python 3.9+ nicht annotiert"
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="62-65"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="62-65"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
Da wir diese Scopes jetzt deklarieren, werden sie in der API-Dokumentation angezeigt, wenn Sie sich einloggen/autorisieren.
Und Sie kรถnnen auswรคhlen, auf welche Scopes Sie Zugriff haben mรถchten: `me` und `items`.
@ -171,56 +218,80 @@ Wir verwenden immer noch dasselbe `OAuth2PasswordRequestForm`. Es enthรคlt eine
Und wir geben die Scopes als Teil des JWT-Tokens zurรผck.
!!! danger "Gefahr"
/// danger | "Gefahr"
Der Einfachheit halber fรผgen wir hier die empfangenen Scopes direkt zum Token hinzu.
Aus Sicherheitsgrรผnden sollten Sie jedoch sicherstellen, dass Sie in Ihrer Anwendung nur die Scopes hinzufรผgen, die der Benutzer tatsรคchlich haben kann, oder die Sie vordefiniert haben.
=== "Python 3.10+"
///
//// tab | Python 3.10+
```Python hl_lines="155"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="155"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="156"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="154"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="155"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="155"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
## Scopes in *Pfadoperationen* und Abhรคngigkeiten deklarieren
Jetzt deklarieren wir, dass die *Pfadoperation* fรผr `/users/me/items/` den Scope `items` erfordert.
@ -237,63 +308,90 @@ Und die Abhรคngigkeitsfunktion `get_current_active_user` kann auch Unterabhรคngi
In diesem Fall erfordert sie den Scope `me` (sie kรถnnte mehr als einen Scope erfordern).
!!! note "Hinweis"
/// note | "Hinweis"
Sie mรผssen nicht unbedingt an verschiedenen Stellen verschiedene Scopes hinzufรผgen.
Wir tun dies hier, um zu demonstrieren, wie **FastAPI** auf verschiedenen Ebenen deklarierte Scopes verarbeitet.
=== "Python 3.10+"
///
//// tab | Python 3.10+
```Python hl_lines="4 139 170"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="4 139 170"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4 140 171"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3 138 167"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="4 139 168"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="4 139 168"
{!> ../../../docs_src/security/tutorial005.py!}
```
!!! info "Technische Details"
////
/// info | "Technische Details"
`Security` ist tatsรคchlich eine Unterklasse von `Depends` und hat nur noch einen zusรคtzlichen Parameter, den wir spรคter kennenlernen werden.
Durch die Verwendung von `Security` anstelle von `Depends` weiรŸ **FastAPI** jedoch, dass es Sicherheits-Scopes deklarieren, intern verwenden und die API mit OpenAPI dokumentieren kann.
Wenn Sie jedoch `Query`, `Path`, `Depends`, `Security` und andere von `fastapi` importieren, handelt es sich tatsรคchlich um Funktionen, die spezielle Klassen zurรผckgeben.
///
## `SecurityScopes` verwenden
Aktualisieren Sie nun die Abhรคngigkeit `get_current_user`.
@ -308,51 +406,72 @@ Wir deklarieren auch einen speziellen Parameter vom Typ `SecurityScopes`, der au
Diese `SecurityScopes`-Klasse รคhnelt `Request` (`Request` wurde verwendet, um das Request-Objekt direkt zu erhalten).
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="8 105"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="8 105"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8 106"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7 104"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8 105"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8 105"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
## Die `scopes` verwenden
Der Parameter `security_scopes` wird vom Typ `SecurityScopes` sein.
@ -365,51 +484,72 @@ Wir erstellen eine `HTTPException`, die wir spรคter an mehreren Stellen wiederve
In diese Exception fรผgen wir (falls vorhanden) die erforderlichen Scopes als durch Leerzeichen getrennten String ein (unter Verwendung von `scope_str`). Wir fรผgen diesen String mit den Scopes in den Header `WWW-Authenticate` ein (das ist Teil der Spezifikation).
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="105 107-115"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="105 107-115"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="106 108-116"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="104 106-114"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="105 107-115"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="105 107-115"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
## Den `username` und das Format der Daten รผberprรผfen
Wir verifizieren, dass wir einen `username` erhalten, und extrahieren die Scopes.
@ -424,102 +564,144 @@ Anstelle beispielsweise eines `dict`s oder etwas anderem, was spรคter in der Anw
Wir verifizieren auch, dass wir einen Benutzer mit diesem Benutzernamen haben, und wenn nicht, lรถsen wir dieselbe Exception aus, die wir zuvor erstellt haben.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="46 116-127"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="46 116-127"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="47 117-128"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="45 115-126"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="46 116-127"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="46 116-127"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
## Die `scopes` verifizieren
Wir รผberprรผfen nun, ob das empfangenen Token alle Scopes enthรคlt, die von dieser Abhรคngigkeit und deren Verwendern (einschlieรŸlich *Pfadoperationen*) gefordert werden. Andernfalls lรถsen wir eine `HTTPException` aus.
Hierzu verwenden wir `security_scopes.scopes`, das eine `list`e mit allen diesen Scopes als `str` enthรคlt.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="128-134"
{!> ../../../docs_src/security/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="128-134"
{!> ../../../docs_src/security/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="129-135"
{!> ../../../docs_src/security/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="127-133"
{!> ../../../docs_src/security/tutorial005_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="128-134"
{!> ../../../docs_src/security/tutorial005_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="128-134"
{!> ../../../docs_src/security/tutorial005.py!}
```
////
## Abhรคngigkeitsbaum und Scopes
Sehen wir uns diesen Abhรคngigkeitsbaum und die Scopes noch einmal an.
@ -545,11 +727,14 @@ So sieht die Hierarchie der Abhรคngigkeiten und Scopes aus:
* `security_scopes.scopes` enthรคlt `["me"]` fรผr die *Pfadoperation* `read_users_me`, da das in der Abhรคngigkeit `get_current_active_user` deklariert ist.
* `security_scopes.scopes` wird `[]` (nichts) fรผr die *Pfadoperation* `read_system_status` enthalten, da diese keine `Security` mit `scopes` deklariert hat, und deren Abhรคngigkeit `get_current_user` ebenfalls keinerlei `scopes` deklariert.
!!! tip "Tipp"
/// tip | "Tipp"
Das Wichtige und โ€žMagischeโ€œ hier ist, dass `get_current_user` fรผr jede *Pfadoperation* eine andere Liste von `scopes` hat, die รผberprรผft werden.
Alles hรคngt von den โ€žScopesโ€œ ab, die in jeder *Pfadoperation* und jeder Abhรคngigkeit im Abhรคngigkeitsbaum fรผr diese bestimmte *Pfadoperation* deklariert wurden.
///
## Weitere Details zu `SecurityScopes`.
Sie kรถnnen `SecurityScopes` an jeder Stelle und an mehreren Stellen verwenden, es muss sich nicht in der โ€žWurzelโ€œ-Abhรคngigkeit befinden.
@ -586,11 +771,14 @@ Am hรคufigsten ist der โ€žImplicitโ€œ-Flow.
Am sichersten ist der โ€žCodeโ€œ-Flow, die Implementierung ist jedoch komplexer, da mehr Schritte erforderlich sind. Da er komplexer ist, schlagen viele Anbieter letztendlich den โ€žImplicitโ€œ-Flow vor.
!!! note "Hinweis"
/// note | "Hinweis"
Es ist รผblich, dass jeder Authentifizierungsanbieter seine Flows anders benennt, um sie zu einem Teil seiner Marke zu machen.
Aber am Ende implementieren sie denselben OAuth2-Standard.
///
**FastAPI** enthรคlt Werkzeuge fรผr alle diese OAuth2-Authentifizierungs-Flows in `fastapi.security.oauth2`.
## `Security` in Dekorator-`dependencies`

145
docs/de/docs/advanced/settings.md

@ -8,14 +8,17 @@ Aus diesem Grund werden diese รผblicherweise in Umgebungsvariablen bereitgestell
## Umgebungsvariablen
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie bereits wissen, was โ€žUmgebungsvariablenโ€œ sind und wie man sie verwendet, kรถnnen Sie gerne mit dem nรคchsten Abschnitt weiter unten fortfahren.
///
Eine <a href="https://de.wikipedia.org/wiki/Umgebungsvariable" class="external-link" target="_blank">Umgebungsvariable</a> (auch bekannt als โ€ženv varโ€œ) ist eine Variable, die sich auรŸerhalb des Python-Codes im Betriebssystem befindet und von Ihrem Python-Code (oder auch von anderen Programmen) gelesen werden kann.
Sie kรถnnen Umgebungsvariablen in der Shell erstellen und verwenden, ohne Python zu benรถtigen:
=== "Linux, macOS, Windows Bash"
//// tab | Linux, macOS, Windows Bash
<div class="termy">
@ -31,7 +34,9 @@ Sie kรถnnen Umgebungsvariablen in der Shell erstellen und verwenden, ohne Python
</div>
=== "Windows PowerShell"
////
//// tab | Windows PowerShell
<div class="termy">
@ -47,6 +52,8 @@ Sie kรถnnen Umgebungsvariablen in der Shell erstellen und verwenden, ohne Python
</div>
////
### Umgebungsvariablen mit Python auslesen
Sie kรถnnen Umgebungsvariablen auch auรŸerhalb von Python im Terminal (oder mit einer anderen Methode) erstellen und diese dann mit Python auslesen.
@ -60,11 +67,14 @@ name = os.getenv("MY_NAME", "World")
print(f"Hello {name} from Python")
```
!!! tip "Tipp"
/// tip | "Tipp"
Das zweite Argument fรผr <a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> ist der zurรผckzugebende Defaultwert.
Wenn nicht angegeben, ist er standardmรครŸig `None`. Hier รผbergeben wir `"World"` als Defaultwert.
///
Dann kรถnnten Sie dieses Python-Programm aufrufen:
<div class="termy">
@ -114,9 +124,12 @@ Hello World from Python
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Weitere Informationen dazu finden Sie unter <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a>.
///
### Typen und Validierung
Diese Umgebungsvariablen kรถnnen nur Text-Zeichenketten verarbeiten, da sie auรŸerhalb von Python liegen und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows, macOS) kompatibel sein mรผssen.
@ -151,9 +164,12 @@ $ pip install "fastapi[all]"
</div>
!!! info
/// info
In Pydantic v1 war das im Hauptpackage enthalten. Jetzt wird es als unabhรคngiges Package verteilt, sodass Sie wรคhlen kรถnnen, ob Sie es installieren mรถchten oder nicht, falls Sie die Funktionalitรคt nicht benรถtigen.
///
### Das `Settings`-Objekt erstellen
Importieren Sie `BaseSettings` aus Pydantic und erstellen Sie eine Unterklasse, ganz รคhnlich wie bei einem Pydantic-Modell.
@ -162,24 +178,34 @@ Auf die gleiche Weise wie bei Pydantic-Modellen deklarieren Sie Klassenattribute
Sie kรถnnen dieselben Validierungs-Funktionen und -Tools verwenden, die Sie fรผr Pydantic-Modelle verwenden, z. B. verschiedene Datentypen und zusรคtzliche Validierungen mit `Field()`.
=== "Pydantic v2"
//// tab | Pydantic v2
```Python hl_lines="2 5-8 11"
{!> ../../../docs_src/settings/tutorial001.py!}
```
=== "Pydantic v1"
////
//// tab | Pydantic v1
/// info
!!! info
In Pydantic v1 wรผrden Sie `BaseSettings` direkt von `pydantic` statt von `pydantic_settings` importieren.
///
```Python hl_lines="2 5-8 11"
{!> ../../../docs_src/settings/tutorial001_pv1.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Fรผr ein schnelles Copy-and-paste verwenden Sie nicht dieses Beispiel, sondern das letzte unten.
///
Wenn Sie dann eine Instanz dieser `Settings`-Klasse erstellen (in diesem Fall als `settings`-Objekt), liest Pydantic die Umgebungsvariablen ohne Berรผcksichtigung der GroรŸ- und Kleinschreibung. Eine Variable `APP_NAME` in GroรŸbuchstaben wird also als Attribut `app_name` gelesen.
Als Nรคchstes werden die Daten konvertiert und validiert. Wenn Sie also dieses `settings`-Objekt verwenden, verfรผgen Sie รผber Daten mit den von Ihnen deklarierten Typen (z. B. ist `items_per_user` ein `int`).
@ -206,9 +232,12 @@ $ ADMIN_EMAIL="[email protected]" APP_NAME="ChimichangApp" uvicorn main:app
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Um mehrere Umgebungsvariablen fรผr einen einzelnen Befehl festzulegen, trennen Sie diese einfach durch ein Leerzeichen und fรผgen Sie alle vor dem Befehl ein.
///
Und dann wรผrde die Einstellung `admin_email` auf `"[email protected]"` gesetzt.
Der `app_name` wรคre `"ChimichangApp"`.
@ -231,9 +260,12 @@ Und dann verwenden Sie diese in einer Datei `main.py`:
{!../../../docs_src/settings/app01/main.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Sie benรถtigen auรŸerdem eine Datei `__init__.py`, wie in [GrรถรŸere Anwendungen โ€“ mehrere Dateien](../tutorial/bigger-applications.md){.internal-link target=_blank} gesehen.
///
## Einstellungen in einer Abhรคngigkeit
In manchen Fรคllen kann es nรผtzlich sein, die Einstellungen mit einer Abhรคngigkeit bereitzustellen, anstatt ein globales Objekt `settings` zu haben, das รผberall verwendet wird.
@ -254,55 +286,76 @@ Beachten Sie, dass wir jetzt keine Standardinstanz `settings = Settings()` erste
Jetzt erstellen wir eine Abhรคngigkeit, die ein neues `config.Settings()` zurรผckgibt.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="6 12-13"
{!> ../../../docs_src/settings/app02_an_py39/main.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="6 12-13"
{!> ../../../docs_src/settings/app02_an/main.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="5 11-12"
{!> ../../../docs_src/settings/app02/main.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Wir werden das `@lru_cache` in Kรผrze besprechen.
Im Moment nehmen Sie an, dass `get_settings()` eine normale Funktion ist.
///
Und dann kรถnnen wir das von der *Pfadoperation-Funktion* als Abhรคngigkeit einfordern und es รผberall dort verwenden, wo wir es brauchen.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="17 19-21"
{!> ../../../docs_src/settings/app02_an_py39/main.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17 19-21"
{!> ../../../docs_src/settings/app02_an/main.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="16 18-20"
{!> ../../../docs_src/settings/app02/main.py!}
```
////
### Einstellungen und Tests
Dann wรคre es sehr einfach, beim Testen ein anderes Einstellungsobjekt bereitzustellen, indem man eine Abhรคngigkeitsรผberschreibung fรผr `get_settings` erstellt:
@ -321,16 +374,22 @@ Wenn Sie viele Einstellungen haben, die sich mรถglicherweise oft รคndern, vielle
Diese Praxis ist so weit verbreitet, dass sie einen Namen hat. Diese Umgebungsvariablen werden รผblicherweise in einer Datei `.env` abgelegt und die Datei wird โ€ždotenvโ€œ genannt.
!!! tip "Tipp"
/// tip | "Tipp"
Eine Datei, die mit einem Punkt (`.`) beginnt, ist eine versteckte Datei in Unix-รคhnlichen Systemen wie Linux und macOS.
Aber eine dotenv-Datei muss nicht unbedingt genau diesen Dateinamen haben.
///
Pydantic unterstรผtzt das Lesen dieser Dateitypen mithilfe einer externen Bibliothek. Weitere Informationen finden Sie unter <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support" class="external-link" target="_blank">Pydantic Settings: Dotenv (.env) support</a>.
!!! tip "Tipp"
/// tip | "Tipp"
Damit das funktioniert, mรผssen Sie `pip install python-dotenv` ausfรผhren.
///
### Die `.env`-Datei
Sie kรถnnten eine `.env`-Datei haben, mit:
@ -344,27 +403,40 @@ APP_NAME="ChimichangApp"
Und dann aktualisieren Sie Ihre `config.py` mit:
=== "Pydantic v2"
//// tab | Pydantic v2
```Python hl_lines="9"
{!> ../../../docs_src/settings/app03_an/config.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Das Attribut `model_config` wird nur fรผr die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter <a href="https://docs.pydantic.dev/latest/concepts/config/" class="external-link" target="_blank">Pydantic: Configuration</a>.
=== "Pydantic v1"
///
////
//// tab | Pydantic v1
```Python hl_lines="9-10"
{!> ../../../docs_src/settings/app03_an/config_pv1.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Die Klasse `Config` wird nur fรผr die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter <a href="https://docs.pydantic.dev/1.10/usage/model_config/" class="external-link" target="_blank">Pydantic Model Config</a>.
!!! info
///
////
/// info
In Pydantic Version 1 erfolgte die Konfiguration in einer internen Klasse `Config`, in Pydantic Version 2 erfolgt sie in einem Attribut `model_config`. Dieses Attribut akzeptiert ein `dict`. Um automatische Codevervollstรคndigung und Inline-Fehlerberichte zu erhalten, kรถnnen Sie `SettingsConfigDict` importieren und verwenden, um dieses `dict` zu definieren.
///
Hier definieren wir die Konfiguration `env_file` innerhalb Ihrer Pydantic-`Settings`-Klasse und setzen den Wert auf den Dateinamen mit der dotenv-Datei, die wir verwenden mรถchten.
### Die `Settings` nur einmal laden mittels `lru_cache`
@ -390,27 +462,36 @@ wรผrden wir dieses Objekt fรผr jeden Request erstellen und die `.env`-Datei fรผr
Da wir jedoch den `@lru_cache`-Dekorator oben verwenden, wird das `Settings`-Objekt nur einmal erstellt, nรคmlich beim ersten Aufruf. โœ”๏ธ
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="1 11"
{!> ../../../docs_src/settings/app03_an_py39/main.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 11"
{!> ../../../docs_src/settings/app03_an/main.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1 10"
{!> ../../../docs_src/settings/app03/main.py!}
```
////
Dann wird bei allen nachfolgenden Aufrufen von `get_settings()`, in den Abhรคngigkeiten fรผr darauffolgende Requests, dasselbe Objekt zurรผckgegeben, das beim ersten Aufruf zurรผckgegeben wurde, anstatt den Code von `get_settings()` erneut auszufรผhren und ein neues `Settings`-Objekt zu erstellen.
#### Technische Details zu `lru_cache`

15
docs/de/docs/advanced/templates.md

@ -31,19 +31,28 @@ $ pip install jinja2
{!../../../docs_src/templates/tutorial001.py!}
```
!!! note "Hinweis"
/// note | "Hinweis"
Vor FastAPI 0.108.0 und Starlette 0.29.0 war `name` der erste Parameter.
AuรŸerdem wurde in frรผheren Versionen das `request`-Objekt als Teil der Schlรผssel-Wert-Paare im Kontext fรผr Jinja2 รผbergeben.
!!! tip "Tipp"
///
/// tip | "Tipp"
Durch die Deklaration von `response_class=HTMLResponse` kann die Dokumentationsoberflรคche erkennen, dass die Response HTML sein wird.
!!! note "Technische Details"
///
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.templating import Jinja2Templates` verwenden.
**FastAPI** bietet dasselbe `starlette.templating` auch via `fastapi.templating` an, als Annehmlichkeit fรผr Sie, den Entwickler. Es kommt aber direkt von Starlette. Das Gleiche gilt fรผr `Request` und `StaticFiles`.
///
## Templates erstellen
Dann kรถnnen Sie unter `templates/item.html` ein Template erstellen, mit z. B. folgendem Inhalt:

40
docs/de/docs/advanced/testing-dependencies.md

@ -28,54 +28,76 @@ Um eine Abhรคngigkeit fรผr das Testen zu รผberschreiben, geben Sie als Schlรผsse
Und dann ruft **FastAPI** diese รœberschreibung anstelle der ursprรผnglichen Abhรคngigkeit auf.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="26-27 30"
{!> ../../../docs_src/dependency_testing/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="28-29 32"
{!> ../../../docs_src/dependency_testing/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="29-30 33"
{!> ../../../docs_src/dependency_testing/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="24-25 28"
{!> ../../../docs_src/dependency_testing/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="28-29 32"
{!> ../../../docs_src/dependency_testing/tutorial001.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Sie kรถnnen eine รœberschreibung fรผr eine Abhรคngigkeit festlegen, die an einer beliebigen Stelle in Ihrer **FastAPI**-Anwendung verwendet wird.
Die ursprรผngliche Abhรคngigkeit kรถnnte in einer *Pfadoperation-Funktion*, einem *Pfadoperation-Dekorator* (wenn Sie den Rรผckgabewert nicht verwenden), einem `.include_router()`-Aufruf, usw. verwendet werden.
FastAPI kann sie in jedem Fall รผberschreiben.
///
AnschlieรŸend kรถnnen Sie Ihre รœberschreibungen zurรผcksetzen (entfernen), indem Sie `app.dependency_overrides` auf ein leeres `dict` setzen:
```Python
app.dependency_overrides = {}
```
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie eine Abhรคngigkeit nur wรคhrend einiger Tests รผberschreiben mรถchten, kรถnnen Sie die รœberschreibung zu Beginn des Tests (innerhalb der Testfunktion) festlegen und am Ende (am Ende der Testfunktion) zurรผcksetzen.
///

5
docs/de/docs/advanced/testing-websockets.md

@ -8,5 +8,8 @@ Dazu verwenden Sie den `TestClient` in einer `with`-Anweisung, eine Verbindung z
{!../../../docs_src/app_testing/tutorial002.py!}
```
!!! note "Hinweis"
/// note | "Hinweis"
Weitere Informationen finden Sie in der Starlette-Dokumentation zum <a href="https://www.starlette.io/testclient/#testing-websocket-sessions" class="external-link" target="_blank">Testen von WebSockets</a>.
///

10
docs/de/docs/advanced/using-request-directly.md

@ -35,18 +35,24 @@ Dazu mรผssen Sie direkt auf den Request zugreifen.
Durch die Deklaration eines *Pfadoperation-Funktionsparameters*, dessen Typ der `Request` ist, weiรŸ **FastAPI**, dass es den `Request` diesem Parameter รผbergeben soll.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass wir in diesem Fall einen Pfad-Parameter zusรคtzlich zum Request-Parameter deklarieren.
Der Pfad-Parameter wird also extrahiert, validiert, in den spezifizierten Typ konvertiert und mit OpenAPI annotiert.
Auf die gleiche Weise kรถnnen Sie wie gewohnt jeden anderen Parameter deklarieren und zusรคtzlich auch den `Request` erhalten.
///
## `Request`-Dokumentation
Weitere Details zum <a href="https://www.starlette.io/requests/" class="external-link" target="_blank">`Request`-Objekt finden Sie in der offiziellen Starlette-Dokumentation</a>.
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.requests import Request` verwenden.
**FastAPI** stellt es direkt zur Verfรผgung, als Komfort fรผr Sie, den Entwickler. Es kommt aber direkt von Starlette.
///

58
docs/de/docs/advanced/websockets.md

@ -50,11 +50,14 @@ Erstellen Sie in Ihrer **FastAPI**-Anwendung einen `websocket`:
{!../../../docs_src/websockets/tutorial001.py!}
```
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.websockets import WebSocket` verwenden.
**FastAPI** stellt den gleichen `WebSocket` direkt zur Verfรผgung, als Annehmlichkeit fรผr Sie, den Entwickler. Er kommt aber direkt von Starlette.
///
## Nachrichten erwarten und Nachrichten senden
In Ihrer WebSocket-Route kรถnnen Sie Nachrichten `await`en und Nachrichten senden.
@ -112,47 +115,66 @@ In WebSocket-Endpunkten kรถnnen Sie Folgendes aus `fastapi` importieren und verw
Diese funktionieren auf die gleiche Weise wie fรผr andere FastAPI-Endpunkte/*Pfadoperationen*:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="68-69 82"
{!> ../../../docs_src/websockets/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="68-69 82"
{!> ../../../docs_src/websockets/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="69-70 83"
{!> ../../../docs_src/websockets/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="66-67 79"
{!> ../../../docs_src/websockets/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="68-69 81"
{!> ../../../docs_src/websockets/tutorial002.py!}
```
!!! info
////
/// info
Da es sich um einen WebSocket handelt, macht es keinen Sinn, eine `HTTPException` auszulรถsen, stattdessen lรถsen wir eine `WebSocketException` aus.
Sie kรถnnen einen โ€žClosingโ€œ-Code verwenden, aus den <a href="https://tools.ietf.org/html/rfc6455#section-7.4.1" class="external-link" target="_blank">gรผltigen Codes, die in der Spezifikation definiert sind</a>.
///
### WebSockets mit Abhรคngigkeiten ausprobieren
Wenn Ihre Datei `main.py` heiรŸt, fรผhren Sie Ihre Anwendung mit Folgendem aus:
@ -174,9 +196,12 @@ Dort kรถnnen Sie einstellen:
* Die โ€žItem IDโ€œ, die im Pfad verwendet wird.
* Das โ€žTokenโ€œ, das als Query-Parameter verwendet wird.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass der Query-โ€žTokenโ€œ von einer Abhรคngigkeit verarbeitet wird.
///
Damit kรถnnen Sie den WebSocket verbinden und dann Nachrichten senden und empfangen:
<img src="/img/tutorial/websockets/image05.png">
@ -185,18 +210,22 @@ Damit kรถnnen Sie den WebSocket verbinden und dann Nachrichten senden und empfan
Wenn eine WebSocket-Verbindung geschlossen wird, lรถst `await websocket.receive_text()` eine `WebSocketDisconnect`-Exception aus, die Sie dann wie in folgendem Beispiel abfangen und behandeln kรถnnen.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="79-81"
{!> ../../../docs_src/websockets/tutorial003_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="81-83"
{!> ../../../docs_src/websockets/tutorial003.py!}
```
////
Zum Ausprobieren:
* ร–ffnen Sie die Anwendung mit mehreren Browser-Tabs.
@ -209,13 +238,16 @@ Das wird die Ausnahme `WebSocketDisconnect` auslรถsen und alle anderen Clients e
Client #1596980209979 left the chat
```
!!! tip "Tipp"
/// tip | "Tipp"
Die obige Anwendung ist ein minimales und einfaches Beispiel, das zeigt, wie Nachrichten verarbeitet und an mehrere WebSocket-Verbindungen gesendet werden.
Beachten Sie jedoch, dass, da alles nur im Speicher in einer einzigen Liste verwaltet wird, es nur funktioniert, wรคhrend der Prozess ausgefรผhrt wird, und nur mit einem einzelnen Prozess.
Wenn Sie etwas benรถtigen, das sich leicht in FastAPI integrieren lรคsst, aber robuster ist und von Redis, PostgreSQL und anderen unterstรผtzt wird, sehen Sie sich <a href="https://github.com/encode/broadcaster" class="external-link" target="_blank">encode/broadcaster</a> an.
///
## Mehr Informationen
Weitere Informationen zu Optionen finden Sie in der Dokumentation von Starlette:

121
docs/de/docs/alternatives.md

@ -30,13 +30,18 @@ Es wird von vielen Unternehmen verwendet, darunter Mozilla, Red Hat und Eventbri
Es war eines der ersten Beispiele fรผr **automatische API-Dokumentation**, und dies war insbesondere eine der ersten Ideen, welche โ€ždie Suche nachโ€œ **FastAPI** inspirierten.
!!! note "Hinweis"
/// note | "Hinweis"
Das Django REST Framework wurde von Tom Christie erstellt. Derselbe Schรถpfer von Starlette und Uvicorn, auf denen **FastAPI** basiert.
///
/// check | "Inspirierte **FastAPI**"
!!! check "Inspirierte **FastAPI**"
Eine automatische API-Dokumentationsoberflรคche zu haben.
///
### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a>
Flask ist ein โ€žMikroframeworkโ€œ, es enthรคlt weder Datenbankintegration noch viele der Dinge, die standardmรครŸig in Django enthalten sind.
@ -51,11 +56,13 @@ Diese Entkopplung der Teile und die Tatsache, dass es sich um ein โ€žMikroframew
Angesichts der Einfachheit von Flask schien es eine gute Ergรคnzung zum Erstellen von APIs zu sein. Als Nรคchstes musste ein โ€žDjango REST Frameworkโ€œ fรผr Flask gefunden werden.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
Ein Mikroframework zu sein. Es einfach zu machen, die benรถtigten Tools und Teile zu kombinieren.
รœber ein einfaches und benutzerfreundliches Routingsystem zu verfรผgen.
///
### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>
@ -91,11 +98,13 @@ def read_url():
Sehen Sie sich die ร„hnlichkeiten in `requests.get(...)` und `@app.get(...)` an.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
* รœber eine einfache und intuitive API zu verfรผgen.
* HTTP-Methodennamen (Operationen) direkt, auf einfache und intuitive Weise zu verwenden.
* Vernรผnftige Standardeinstellungen zu haben, aber auch mรคchtige Einstellungsmรถglichkeiten.
///
### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI/OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a>
@ -109,7 +118,8 @@ Irgendwann wurde Swagger an die Linux Foundation รผbergeben und in OpenAPI umben
Aus diesem Grund spricht man bei Version 2.0 hรคufig von โ€žSwaggerโ€œ und ab Version 3 von โ€žOpenAPIโ€œ.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
Einen offenen Standard fรผr API-Spezifikationen zu รผbernehmen und zu verwenden, anstelle eines benutzerdefinierten Schemas.
Und Standard-basierte Tools fรผr die Oberflรคche zu integrieren:
@ -119,6 +129,8 @@ Aus diesem Grund spricht man bei Version 2.0 hรคufig von โ€žSwaggerโ€œ und ab Ve
Diese beiden wurden ausgewรคhlt, weil sie ziemlich beliebt und stabil sind, aber bei einer schnellen Suche kรถnnten Sie Dutzende alternativer Benutzeroberflรคchen fรผr OpenAPI finden (welche Sie mit **FastAPI** verwenden kรถnnen).
///
### Flask REST Frameworks
Es gibt mehrere Flask REST Frameworks, aber nachdem ich die Zeit und Arbeit investiert habe, sie zu untersuchen, habe ich festgestellt, dass viele nicht mehr unterstรผtzt werden oder abgebrochen wurden und dass mehrere fortbestehende Probleme sie unpassend machten.
@ -135,9 +147,12 @@ Fรผr diese Funktionen wurde Marshmallow entwickelt. Es ist eine groรŸartige Bibl
Aber sie wurde erstellt, bevor Typhinweise in Python existierten. Um also ein <abbr title="die Definition, wie Daten geformt sein werden sollen">Schema</abbr> zu definieren, mรผssen Sie bestimmte Werkzeuge und Klassen verwenden, die von Marshmallow bereitgestellt werden.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
Code zu verwenden, um โ€žSchemasโ€œ zu definieren, welche Datentypen und Validierung automatisch bereitstellen.
///
### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a>
Eine weitere wichtige Funktion, die von APIs benรถtigt wird, ist das <abbr title="Lesen und Konvertieren nach Python-Daten">Parsen</abbr> von Daten aus eingehenden Requests.
@ -148,12 +163,18 @@ Es verwendet unter der Haube Marshmallow, um die Datenvalidierung durchzufรผhren
Es ist ein groรŸartiges Tool und ich habe es auch oft verwendet, bevor ich **FastAPI** hatte.
!!! info
/// info
Webargs wurde von denselben Marshmallow-Entwicklern erstellt.
!!! check "Inspirierte **FastAPI**"
///
/// check | "Inspirierte **FastAPI**"
Eingehende Requestdaten automatisch zu validieren.
///
### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a>
Marshmallow und Webargs bieten Validierung, Parsen und Serialisierung als Plugins.
@ -172,13 +193,18 @@ Aber dann haben wir wieder das Problem einer Mikrosyntax innerhalb eines Python-
Der Texteditor kann dabei nicht viel helfen. Und wenn wir Parameter oder Marshmallow-Schemas รคndern und vergessen, auch den YAML-Docstring zu รคndern, wรคre das generierte Schema veraltet.
!!! info
/// info
APISpec wurde von denselben Marshmallow-Entwicklern erstellt.
///
/// check | "Inspirierte **FastAPI**"
!!! check "Inspirierte **FastAPI**"
Den offenen Standard fรผr APIs, OpenAPI, zu unterstรผtzen.
///
### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a>
Hierbei handelt es sich um ein Flask-Plugin, welches Webargs, Marshmallow und APISpec miteinander verbindet.
@ -199,12 +225,18 @@ Die Verwendung fรผhrte zur Entwicklung mehrerer Flask-Full-Stack-Generatoren. Di
Und dieselben Full-Stack-Generatoren bildeten die Basis der [**FastAPI**-Projektgeneratoren](project-generation.md){.internal-link target=_blank}.
!!! info
/// info
Flask-apispec wurde von denselben Marshmallow-Entwicklern erstellt.
!!! check "Inspirierte **FastAPI**"
///
/// check | "Inspirierte **FastAPI**"
Das OpenAPI-Schema automatisch zu generieren, aus demselben Code, welcher die Serialisierung und Validierung definiert.
///
### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (und <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>)
Dies ist nicht einmal Python, NestJS ist ein von Angular inspiriertes JavaScript (TypeScript) NodeJS Framework.
@ -219,25 +251,34 @@ Da TypeScript-Daten jedoch nach der Kompilierung nach JavaScript nicht erhalten
Es kann nicht sehr gut mit verschachtelten Modellen umgehen. Wenn es sich beim JSON-Body in der Anfrage also um ein JSON-Objekt mit inneren Feldern handelt, die wiederum verschachtelte JSON-Objekte sind, kann er nicht richtig dokumentiert und validiert werden.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
Python-Typen zu verwenden, um eine hervorragende Editorunterstรผtzung zu erhalten.
รœber ein leistungsstarkes Dependency Injection System zu verfรผgen. Eine Mรถglichkeit zu finden, Codeverdoppelung zu minimieren.
///
### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a>
Es war eines der ersten extrem schnellen Python-Frameworks, welches auf `asyncio` basierte. Es wurde so gestaltet, dass es Flask sehr รคhnlich ist.
!!! note "Technische Details"
/// note | "Technische Details"
Es verwendete <a href="https://github.com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a> anstelle der standardmรครŸigen Python-`asyncio`-Schleife. Das hat es so schnell gemacht.
Hat eindeutig Uvicorn und Starlette inspiriert, welche derzeit in offenen Benchmarks schneller als Sanic sind.
!!! check "Inspirierte **FastAPI**"
///
/// check | "Inspirierte **FastAPI**"
Einen Weg zu finden, eine hervorragende Performanz zu haben.
Aus diesem Grund basiert **FastAPI** auf Starlette, da dieses das schnellste verfรผgbare Framework ist (getestet in Benchmarks von Dritten).
///
### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a>
Falcon ist ein weiteres leistungsstarkes Python-Framework. Es ist minimalistisch konzipiert und dient als Grundlage fรผr andere Frameworks wie Hug.
@ -246,13 +287,16 @@ Es ist so konzipiert, dass es รผber Funktionen verfรผgt, welche zwei Parameter e
Daher mรผssen Datenvalidierung, Serialisierung und Dokumentation im Code und nicht automatisch erfolgen. Oder sie mรผssen als Framework oberhalb von Falcon implementiert werden, so wie Hug. Dieselbe Unterscheidung findet auch in anderen Frameworks statt, die vom Design von Falcon inspiriert sind und ein Requestobjekt und ein Responseobjekt als Parameter haben.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
Wege zu finden, eine groรŸartige Performanz zu erzielen.
Zusammen mit Hug (da Hug auf Falcon basiert), einen `response`-Parameter in Funktionen zu deklarieren.
Obwohl er in FastAPI optional ist und hauptsรคchlich zum Festlegen von Headern, Cookies und alternativen Statuscodes verwendet wird.
///
### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a>
Ich habe Molten in den ersten Phasen der Entwicklung von **FastAPI** entdeckt. Und es hat ganz รคhnliche Ideen:
@ -269,11 +313,14 @@ Das Dependency Injection System erfordert eine Vorab-Registrierung der Abhรคngig
Routen werden an einer einzigen Stelle deklariert, indem Funktionen verwendet werden, die an anderen Stellen deklariert wurden (anstatt Dekoratoren zu verwenden, welche direkt รผber der Funktion platziert werden kรถnnen, welche den Endpunkt verarbeitet). Dies รคhnelt eher der Vorgehensweise von Django als der Vorgehensweise von Flask (und Starlette). Es trennt im Code Dinge, die relativ eng miteinander gekoppelt sind.
!!! check "Inspirierte **FastAPI**"
/// check | "Inspirierte **FastAPI**"
Zusรคtzliche Validierungen fรผr Datentypen zu definieren, mithilfe des โ€žDefaultโ€œ-Werts von Modellattributen. Dies verbessert die Editorunterstรผtzung und war zuvor in Pydantic nicht verfรผgbar.
Das hat tatsรคchlich dazu gefรผhrt, dass Teile von Pydantic aktualisiert wurden, um denselben Validierungsdeklarationsstil zu unterstรผtzen (diese gesamte Funktionalitรคt ist jetzt bereits in Pydantic verfรผgbar).
///
### <a href="https://www.hug.rest/" class="external-link" target="_blank">Hug</a>
Hug war eines der ersten Frameworks, welches die Deklaration von API-Parametertypen mithilfe von Python-Typhinweisen implementierte. Das war eine groรŸartige Idee, die andere Tools dazu inspirierte, dasselbe zu tun.
@ -288,16 +335,22 @@ Es verfรผgt รผber eine interessante, ungewรถhnliche Funktion: Mit demselben Fram
Da es auf dem bisherigen Standard fรผr synchrone Python-Webframeworks (WSGI) basiert, kann es nicht mit Websockets und anderen Dingen umgehen, verfรผgt aber dennoch รผber eine hohe Performanz.
!!! info
/// info
Hug wurde von Timothy Crosley erstellt, dem gleichen Schรถpfer von <a href="https://github.com/timothycrosley/isort" class="external-link" target="_blank">`isort`</a>, einem groรŸartigen Tool zum automatischen Sortieren von Importen in Python-Dateien.
!!! check "Ideen, die **FastAPI** inspiriert haben"
///
/// check | "Ideen, die **FastAPI** inspiriert haben"
Hug inspirierte Teile von APIStar und war eines der Tools, die ich am vielversprechendsten fand, neben APIStar.
Hug hat dazu beigetragen, **FastAPI** dazu zu inspirieren, Python-Typhinweise zum Deklarieren von Parametern zu verwenden und ein Schema zu generieren, das die API automatisch definiert.
Hug inspirierte **FastAPI** dazu, einen `response`-Parameter in Funktionen zu deklarieren, um Header und Cookies zu setzen.
///
### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (โ‰ฆ 0.5)
Kurz bevor ich mich entschied, **FastAPI** zu erstellen, fand ich den **APIStar**-Server. Er hatte fast alles, was ich suchte, und ein tolles Design.
@ -322,14 +375,18 @@ Es handelte sich nicht lรคnger um ein API-Webframework, da sich der Entwickler a
Jetzt handelt es sich bei APIStar um eine Reihe von Tools zur Validierung von OpenAPI-Spezifikationen, nicht um ein Webframework.
!!! info
/// info
APIStar wurde von Tom Christie erstellt. Derselbe, welcher Folgendes erstellt hat:
* Django REST Framework
* Starlette (auf welchem **FastAPI** basiert)
* Uvicorn (verwendet von Starlette und **FastAPI**)
!!! check "Inspirierte **FastAPI**"
///
/// check | "Inspirierte **FastAPI**"
Zu existieren.
Die Idee, mehrere Dinge (Datenvalidierung, Serialisierung und Dokumentation) mit denselben Python-Typen zu deklarieren, welche gleichzeitig eine hervorragende Editorunterstรผtzung bieten, hielt ich fรผr eine brillante Idee.
@ -340,6 +397,8 @@ Jetzt handelt es sich bei APIStar um eine Reihe von Tools zur Validierung von Op
Ich betrachte **FastAPI** als einen โ€žspirituellen Nachfolgerโ€œ von APIStar, welcher die Funktionen, das Typsystem und andere Teile verbessert und erweitert, basierend auf den Erkenntnissen aus all diesen frรผheren Tools.
///
## Verwendet von **FastAPI**
### <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a>
@ -350,11 +409,14 @@ Das macht es รคuรŸerst intuitiv.
Es ist vergleichbar mit Marshmallow. Obwohl es in Benchmarks schneller als Marshmallow ist. Und da es auf den gleichen Python-Typhinweisen basiert, ist die Editorunterstรผtzung groรŸartig.
!!! check "**FastAPI** verwendet es, um"
/// check | "**FastAPI** verwendet es, um"
Die gesamte Datenvalidierung, Datenserialisierung und automatische Modelldokumentation (basierend auf JSON Schema) zu erledigen.
**FastAPI** nimmt dann, abgesehen von all den anderen Dingen, die es tut, dieses JSON-Schema und fรผgt es in OpenAPI ein.
///
### <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a>
Starlette ist ein leichtgewichtiges <abbr title="Der neue Standard fรผr die Erstellung asynchroner Python-Webanwendungen">ASGI</abbr>-Framework/Toolkit, welches sich ideal fรผr die Erstellung hochperformanter asynchroner Dienste eignet.
@ -382,18 +444,24 @@ Es bietet jedoch keine automatische Datenvalidierung, Serialisierung oder Dokume
Das ist eines der wichtigsten Dinge, welche **FastAPI** hinzufรผgt, alles basierend auf Python-Typhinweisen (mit Pydantic). Das, plus, das Dependency Injection System, Sicherheitswerkzeuge, OpenAPI-Schemagenerierung, usw.
!!! note "Technische Details"
/// note | "Technische Details"
ASGI ist ein neuer โ€žStandardโ€œ, welcher von Mitgliedern des Django-Kernteams entwickelt wird. Es handelt sich immer noch nicht um einen โ€žPython-Standardโ€œ (ein PEP), obwohl sie gerade dabei sind, das zu tun.
Dennoch wird es bereits von mehreren Tools als โ€žStandardโ€œ verwendet. Das verbessert die Interoperabilitรคt erheblich, da Sie Uvicorn mit jeden anderen ASGI-Server (wie Daphne oder Hypercorn) tauschen oder ASGI-kompatible Tools wie `python-socketio` hinzufรผgen kรถnnen.
!!! check "**FastAPI** verwendet es, um"
///
/// check | "**FastAPI** verwendet es, um"
Alle Kern-Webaspekte zu handhaben. Und fรผgt Funktionen obenauf.
Die Klasse `FastAPI` selbst erbt direkt von der Klasse `Starlette`.
Alles, was Sie also mit Starlette machen kรถnnen, kรถnnen Sie direkt mit **FastAPI** machen, da es sich im Grunde um Starlette auf Steroiden handelt.
///
### <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>
Uvicorn ist ein blitzschneller ASGI-Server, der auf uvloop und httptools basiert.
@ -402,13 +470,16 @@ Es handelt sich nicht um ein Webframework, sondern um einen Server. Beispielswei
Es ist der empfohlene Server fรผr Starlette und **FastAPI**.
!!! check "**FastAPI** empfiehlt es als"
/// check | "**FastAPI** empfiehlt es als"
Hauptwebserver zum Ausfรผhren von **FastAPI**-Anwendungen.
Sie kรถnnen ihn mit Gunicorn kombinieren, um einen asynchronen Multiprozess-Server zu erhalten.
Weitere Details finden Sie im Abschnitt [Deployment](deployment/index.md){.internal-link target=_blank}.
///
## Benchmarks und Geschwindigkeit
Um den Unterschied zwischen Uvicorn, Starlette und FastAPI zu verstehen, zu vergleichen und zu sehen, lesen Sie den Abschnitt รผber [Benchmarks](benchmarks.md){.internal-link target=_blank}.

20
docs/de/docs/async.md

@ -21,9 +21,12 @@ async def read_results():
return results
```
!!! note
/// note
Sie kรถnnen `await` nur innerhalb von Funktionen verwenden, die mit `async def` erstellt wurden.
///
---
Wenn Sie eine Bibliothek eines Dritten verwenden, die mit etwas kommuniziert (einer Datenbank, einer API, dem Dateisystem, usw.) und welche die Verwendung von `await` nicht unterstรผtzt (dies ist derzeit bei den meisten Datenbankbibliotheken der Fall), dann deklarieren Sie Ihre *Pfadoperation-Funktionen* ganz normal nur mit `def`, etwa:
@ -136,9 +139,12 @@ Sie und Ihr Schwarm essen die Burger und haben eine schรถne Zeit. โœจ
<img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">
!!! info
/// info
Die wunderschรถnen Illustrationen stammen von <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. ๐ŸŽจ
///
---
Stellen Sie sich vor, Sie wรคren das Computersystem / Programm ๐Ÿค– in dieser Geschichte.
@ -199,9 +205,12 @@ Sie essen sie und sind fertig. โน
Es wurde nicht viel geredet oder geflirtet, da die meiste Zeit mit Warten ๐Ÿ•™ vor der Theke verbracht wurde. ๐Ÿ˜ž
!!! info
/// info
Die wunderschรถnen Illustrationen stammen von <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. ๐ŸŽจ
///
---
In diesem Szenario der parallelen Hamburger sind Sie ein Computersystem / Programm ๐Ÿค– mit zwei Prozessoren (Sie und Ihr Schwarm), die beide warten ๐Ÿ•™ und ihre Aufmerksamkeit darauf verwenden, โ€žlange Zeit vor der Theke zu wartenโ€œ ๐Ÿ•™.
@ -392,13 +401,16 @@ All das ist es, was FastAPI (via Starlette) befeuert und es eine so beeindrucken
## Sehr technische Details
!!! warning "Achtung"
/// warning | "Achtung"
Das folgende kรถnnen Sie wahrscheinlich รผberspringen.
Dies sind sehr technische Details darรผber, wie **FastAPI** unter der Haube funktioniert.
Wenn Sie รผber gute technische Kenntnisse verfรผgen (Coroutinen, Threads, Blocking, usw.) und neugierig sind, wie FastAPI mit `async def`s im Vergleich zu normalen `def`s umgeht, fahren Sie fort.
///
### Pfadoperation-Funktionen
Wenn Sie eine *Pfadoperation-Funktion* mit normalem `def` anstelle von `async def` deklarieren, wird sie in einem externen Threadpool ausgefรผhrt, der dann `await`et wird, anstatt direkt aufgerufen zu werden (da dies den Server blockieren wรผrde).

65
docs/de/docs/contributing.md

@ -24,7 +24,7 @@ Das erstellt ein Verzeichnis `./env/` mit den Python-Binรคrdateien und Sie kรถnn
Aktivieren Sie die neue Umgebung mit:
=== "Linux, macOS"
//// tab | Linux, macOS
<div class="termy">
@ -34,7 +34,9 @@ Aktivieren Sie die neue Umgebung mit:
</div>
=== "Windows PowerShell"
////
//// tab | Windows PowerShell
<div class="termy">
@ -44,7 +46,9 @@ Aktivieren Sie die neue Umgebung mit:
</div>
=== "Windows Bash"
////
//// tab | Windows Bash
Oder, wenn Sie Bash fรผr Windows verwenden (z. B. <a href="https://gitforwindows.org/" class="external-link" target="_blank">Git Bash</a>):
@ -56,9 +60,11 @@ Aktivieren Sie die neue Umgebung mit:
</div>
////
Um zu รผberprรผfen, ob es funktioniert hat, geben Sie ein:
=== "Linux, macOS, Windows Bash"
//// tab | Linux, macOS, Windows Bash
<div class="termy">
@ -70,7 +76,9 @@ Um zu รผberprรผfen, ob es funktioniert hat, geben Sie ein:
</div>
=== "Windows PowerShell"
////
//// tab | Windows PowerShell
<div class="termy">
@ -82,6 +90,8 @@ Um zu รผberprรผfen, ob es funktioniert hat, geben Sie ein:
</div>
////
Wenn die `pip` Binรคrdatei unter `env/bin/pip` angezeigt wird, hat es funktioniert. ๐ŸŽ‰
Stellen Sie sicher, dass Sie รผber die neueste Version von pip in Ihrer lokalen Umgebung verfรผgen, um Fehler bei den nรคchsten Schritten zu vermeiden:
@ -96,11 +106,14 @@ $ python -m pip install --upgrade pip
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Aktivieren Sie jedes Mal, wenn Sie ein neues Package mit `pip` in dieser Umgebung installieren, die Umgebung erneut.
Dadurch wird sichergestellt, dass Sie, wenn Sie ein von diesem Package installiertes Terminalprogramm verwenden, das Programm aus Ihrer lokalen Umgebung verwenden und kein anderes, das global installiert sein kรถnnte.
///
### Benรถtigtes mit pip installieren
Nachdem Sie die Umgebung wie oben beschrieben aktiviert haben:
@ -125,11 +138,14 @@ Und wenn Sie diesen lokalen FastAPI-Quellcode aktualisieren und dann die Python-
Auf diese Weise mรผssen Sie Ihre lokale Version nicht โ€žinstallierenโ€œ, um jede ร„nderung testen zu kรถnnen.
!!! note "Technische Details"
/// note | "Technische Details"
Das geschieht nur, wenn Sie die Installation mit der enthaltenen `requirements.txt` durchfรผhren, anstatt `pip install fastapi` direkt auszufรผhren.
Das liegt daran, dass in der Datei `requirements.txt` die lokale Version von FastAPI mit der Option `-e` fรผr die Installation im โ€žeditierbarenโ€œ Modus markiert ist.
///
### Den Code formatieren
Es gibt ein Skript, das, wenn Sie es ausfรผhren, Ihren gesamten Code formatiert und bereinigt:
@ -170,7 +186,8 @@ Das stellt die Dokumentation unter `http://127.0.0.1:8008` bereit.
Auf diese Weise kรถnnen Sie die Dokumentation/Quelldateien bearbeiten und die ร„nderungen live sehen.
!!! tip "Tipp"
/// tip | "Tipp"
Alternativ kรถnnen Sie die Schritte des Skripts auch manuell ausfรผhren.
Gehen Sie in das Verzeichnis fรผr die entsprechende Sprache. Das fรผr die englischsprachige Hauptdokumentation befindet sich unter `docs/en/`:
@ -185,6 +202,8 @@ Auf diese Weise kรถnnen Sie die Dokumentation/Quelldateien bearbeiten und die ร„
$ mkdocs serve --dev-addr 8008
```
///
#### Typer-CLI (optional)
Die Anleitung hier zeigt Ihnen, wie Sie das Skript unter `./scripts/docs.py` direkt mit dem `python` Programm verwenden.
@ -210,9 +229,12 @@ Die Dokumentation verwendet <a href="https://www.mkdocs.org/" class="external-li
Und es gibt zusรคtzliche Tools/Skripte fรผr รœbersetzungen, in `./scripts/docs.py`.
!!! tip "Tipp"
/// tip | "Tipp"
Sie mรผssen sich den Code in `./scripts/docs.py` nicht anschauen, verwenden Sie ihn einfach in der Kommandozeile.
///
Die gesamte Dokumentation befindet sich im Markdown-Format im Verzeichnis `./docs/en/`.
Viele der Tutorials enthalten Codeblรถcke.
@ -261,11 +283,14 @@ Hier sind die Schritte, die Ihnen bei รœbersetzungen helfen.
* Sehen Sie diese Pull Requests durch (Review), schlagen Sie ร„nderungen vor, oder segnen Sie sie ab (Approval). Bei den Sprachen, die ich nicht spreche, warte ich, bis mehrere andere die รœbersetzung durchgesehen haben, bevor ich den Pull Request merge.
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen <a href="https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/commenting-on-a-pull-request" class="external-link" target="_blank">Kommentare mit ร„nderungsvorschlรคgen</a> zu vorhandenen Pull Requests hinzufรผgen.
Schauen Sie sich die Dokumentation an, <a href="https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-request-reviews" class="external-link" target="_blank">wie man ein Review zu einem Pull Request hinzufรผgt</a>, welches den PR absegnet oder ร„nderungen vorschlรคgt.
///
* รœberprรผfen Sie, ob es eine <a href="https://github.com/fastapi/fastapi/discussions/categories/translations" class="external-link" target="_blank">GitHub-Diskussion</a> gibt, die รœbersetzungen fรผr Ihre Sprache koordiniert. Sie kรถnnen sie abonnieren, und wenn ein neuer Pull Request zum Review vorliegt, wird der Diskussion automatisch ein Kommentar hinzugefรผgt.
* Wenn Sie Seiten รผbersetzen, fรผgen Sie einen einzelnen Pull Request pro รผbersetzter Seite hinzu. Dadurch wird es fรผr andere viel einfacher, ihn zu durchzusehen.
@ -278,9 +303,12 @@ Angenommen, Sie mรถchten eine Seite fรผr eine Sprache รผbersetzen, die bereits
Im Spanischen lautet der Zwei-Buchstaben-Code `es`. Das Verzeichnis fรผr spanische รœbersetzungen befindet sich also unter `docs/es/`.
!!! tip "Tipp"
/// tip | "Tipp"
Die Haupt (โ€žoffizielleโ€œ) Sprache ist Englisch und befindet sich unter `docs/en/`.
///
Fรผhren Sie nun den Live-Server fรผr die Dokumentation auf Spanisch aus:
<div class="termy">
@ -296,7 +324,8 @@ $ python ./scripts/docs.py live es
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Alternativ kรถnnen Sie die Schritte des Skripts auch manuell ausfรผhren.
Gehen Sie in das Sprachverzeichnis, fรผr die spanischen รœbersetzungen ist das `docs/es/`:
@ -311,6 +340,8 @@ $ python ./scripts/docs.py live es
$ mkdocs serve --dev-addr 8008
```
///
Jetzt kรถnnen Sie auf <a href="http://127.0.0.1:8008" class="external-link" target="_blank">http://127.0.0.1:8008</a> gehen und Ihre ร„nderungen live sehen.
Sie werden sehen, dass jede Sprache alle Seiten hat. Einige Seiten sind jedoch nicht รผbersetzt und haben oben eine Info-Box, dass die รœbersetzung noch fehlt.
@ -329,9 +360,12 @@ docs/en/docs/features.md
docs/es/docs/features.md
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass die einzige ร„nderung in Pfad und Dateiname der Sprachcode ist, von `en` zu `es`.
///
Wenn Sie in Ihrem Browser nachsehen, werden Sie feststellen, dass die Dokumentation jetzt Ihren neuen Abschnitt anzeigt (die Info-Box oben ist verschwunden). ๐ŸŽ‰
Jetzt kรถnnen Sie alles รผbersetzen und beim Speichern sehen, wie es aussieht.
@ -365,9 +399,12 @@ Obiges Kommando hat eine Datei `docs/ht/mkdocs.yml` mit einer Minimal-Konfigurat
INHERIT: ../en/mkdocs.yml
```
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen diese Datei mit diesem Inhalt auch einfach manuell erstellen.
///
Das Kommando hat auch eine Dummy-Datei `docs/ht/index.md` fรผr die Hauptseite erstellt. Sie kรถnnen mit der รœbersetzung dieser Datei beginnen.
Sie kรถnnen nun mit den obigen Instruktionen fรผr eine โ€žvorhandene Spracheโ€œ fortfahren.

20
docs/de/docs/deployment/concepts.md

@ -151,11 +151,14 @@ Und dennoch mรถchten Sie wahrscheinlich nicht, dass die Anwendung tot bleibt, we
Aber in den Fรคllen mit wirklich schwerwiegenden Fehlern, die den laufenden **Prozess** zum Absturz bringen, benรถtigen Sie eine externe Komponente, die den Prozess **neu startet**, zumindest ein paar Mal ...
!!! tip "Tipp"
/// tip | "Tipp"
... Obwohl es wahrscheinlich keinen Sinn macht, sie immer wieder neu zu starten, wenn die gesamte Anwendung einfach **sofort abstรผrzt**. Aber in diesen Fรคllen werden Sie es wahrscheinlich wรคhrend der Entwicklung oder zumindest direkt nach dem Deployment bemerken.
Konzentrieren wir uns also auf die Hauptfรคlle, in denen die Anwendung in bestimmten Fรคllen **in der Zukunft** vรถllig abstรผrzen kรถnnte und es dann dennoch sinnvoll ist, sie neu zu starten.
///
Sie mรถchten wahrscheinlich, dass eine **externe Komponente** fรผr den Neustart Ihrer Anwendung verantwortlich ist, da zu diesem Zeitpunkt dieselbe Anwendung mit Uvicorn und Python bereits abgestรผrzt ist und es daher nichts im selben Code derselben Anwendung gibt, was etwas dagegen tun kann.
### Beispieltools zum automatischen Neustart
@ -238,11 +241,14 @@ Hier sind einige mรถgliche Kombinationen und Strategien:
* **Cloud-Dienste**, welche das fรผr Sie erledigen
* Der Cloud-Dienst wird wahrscheinlich **die Replikation fรผr Sie รผbernehmen**. Er wรผrde Sie mรถglicherweise **einen auszufรผhrenden Prozess** oder ein **zu verwendendes Container-Image** definieren lassen, in jedem Fall wรคre es hรถchstwahrscheinlich **ein einzelner Uvicorn-Prozess**, und der Cloud-Dienst wรคre auch verantwortlich fรผr die Replikation.
!!! tip "Tipp"
/// tip | "Tipp"
Machen Sie sich keine Sorgen, wenn einige dieser Punkte zu **Containern**, Docker oder Kubernetes noch nicht viel Sinn ergeben.
Ich werde Ihnen in einem zukรผnftigen Kapitel mehr รผber Container-Images, Docker, Kubernetes, usw. erzรคhlen: [FastAPI in Containern โ€“ Docker](docker.md){.internal-link target=_blank}.
///
## Schritte vor dem Start
Es gibt viele Fรคlle, in denen Sie, **bevor Sie Ihre Anwendung starten**, einige Schritte ausfรผhren mรถchten.
@ -257,11 +263,14 @@ Und Sie mรผssen sicherstellen, dass es sich um einen einzelnen Prozess handelt,
Natรผrlich gibt es Fรคlle, in denen es kein Problem darstellt, die Vorab-Schritte mehrmals auszufรผhren. In diesem Fall ist die Handhabung viel einfacher.
!!! tip "Tipp"
/// tip | "Tipp"
Bedenken Sie auรŸerdem, dass Sie, abhรคngig von Ihrer Einrichtung, in manchen Fรคllen **gar keine Vorab-Schritte** benรถtigen, bevor Sie die Anwendung starten.
In diesem Fall mรผssen Sie sich darรผber keine Sorgen machen. ๐Ÿคท
///
### Beispiele fรผr Strategien fรผr Vorab-Schritte
Es hรคngt **stark** davon ab, wie Sie **Ihr System bereitstellen**, und hรคngt wahrscheinlich mit der Art und Weise zusammen, wie Sie Programme starten, Neustarts durchfรผhren, usw.
@ -272,9 +281,12 @@ Hier sind einige mรถgliche Ideen:
* Ein Bash-Skript, das die Vorab-Schritte ausfรผhrt und dann Ihre Anwendung startet
* Sie benรถtigen immer noch eine Mรถglichkeit, *dieses* Bash-Skript zu starten/neu zu starten, Fehler zu erkennen, usw.
!!! tip "Tipp"
/// tip | "Tipp"
Konkretere Beispiele hierfรผr mit Containern gebe ich Ihnen in einem spรคteren Kapitel: [FastAPI in Containern โ€“ Docker](docker.md){.internal-link target=_blank}.
///
## Ressourcennutzung
Ihr(e) Server ist (sind) eine **Ressource**, welche Sie mit Ihren Programmen, der Rechenzeit auf den CPUs und dem verfรผgbaren RAM-Speicher verbrauchen oder **nutzen** kรถnnen.

50
docs/de/docs/deployment/docker.md

@ -4,9 +4,12 @@ Beim Deployment von FastAPI-Anwendungen besteht ein gรคngiger Ansatz darin, ein
Die Verwendung von Linux-Containern bietet mehrere Vorteile, darunter **Sicherheit**, **Replizierbarkeit**, **Einfachheit** und andere.
!!! tip "Tipp"
/// tip | "Tipp"
Sie haben es eilig und kennen sich bereits aus? Springen Sie zum [`Dockerfile` unten ๐Ÿ‘‡](#ein-docker-image-fur-fastapi-erstellen).
///
<Details>
<summary>Dockerfile-Vorschau ๐Ÿ‘€</summary>
@ -130,11 +133,14 @@ Successfully installed fastapi pydantic uvicorn
</div>
!!! info
/// info
Es gibt andere Formate und Tools zum Definieren und Installieren von Paketabhรคngigkeiten.
Ich zeige Ihnen spรคter in einem Abschnitt unten ein Beispiel unter Verwendung von Poetry. ๐Ÿ‘‡
///
### Den **FastAPI**-Code erstellen
* Erstellen Sie ein `app`-Verzeichnis und betreten Sie es.
@ -222,9 +228,12 @@ CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
Da das Programm unter `/code` gestartet wird und sich darin das Verzeichnis `./app` mit Ihrem Code befindet, kann **Uvicorn** `app` sehen und aus `app.main` **importieren**.
!!! tip "Tipp"
/// tip | "Tipp"
Lernen Sie, was jede Zeile bewirkt, indem Sie auf die Zahlenblasen im Code klicken. ๐Ÿ‘†
///
Sie sollten jetzt eine Verzeichnisstruktur wie diese haben:
```
@ -293,11 +302,14 @@ $ docker build -t myimage .
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie das `.` am Ende, es entspricht `./` und teilt Docker mit, welches Verzeichnis zum Erstellen des Containerimages verwendet werden soll.
In diesem Fall handelt es sich um dasselbe aktuelle Verzeichnis (`.`).
///
### Den Docker-Container starten
* Fรผhren Sie einen Container basierend auf Ihrem Image aus:
@ -394,9 +406,12 @@ Wenn wir uns nur auf das **Containerimage** fรผr eine FastAPI-Anwendung (und sp
Es kรถnnte sich um einen anderen Container handeln, zum Beispiel mit <a href="https://traefik.io/" class="external-link" target="_blank">Traefik</a>, welcher **HTTPS** und **automatischen** Erwerb von **Zertifikaten** handhabt.
!!! tip "Tipp"
/// tip | "Tipp"
Traefik verfรผgt รผber Integrationen mit Docker, Kubernetes und anderen, sodass Sie damit ganz einfach HTTPS fรผr Ihre Container einrichten und konfigurieren kรถnnen.
///
Alternativ kรถnnte HTTPS von einem Cloud-Anbieter als einer seiner Dienste gehandhabt werden (wรคhrend die Anwendung weiterhin in einem Container ausgefรผhrt wird).
## Beim Hochfahren ausfรผhren und Neustarts
@ -423,9 +438,12 @@ Bei der Verwendung von Containern ist normalerweise eine Komponente vorhanden, *
Da diese Komponente die **Last** an Requests aufnehmen und diese (hoffentlich) **ausgewogen** auf die Worker verteilen wรผrde, wird sie รผblicherweise auch **Load Balancer** โ€“ Lastverteiler โ€“ genannt.
!!! tip "Tipp"
/// tip | "Tipp"
Die gleiche **TLS-Terminierungsproxy**-Komponente, die fรผr HTTPS verwendet wird, wรคre wahrscheinlich auch ein **Load Balancer**.
///
Und wenn Sie mit Containern arbeiten, verfรผgt das gleiche System, mit dem Sie diese starten und verwalten, bereits รผber interne Tools, um die **Netzwerkkommunikation** (z. B. HTTP-Requests) von diesem **Load Balancer** (das kรถnnte auch ein **TLS-Terminierungsproxy** sein) zu den Containern mit Ihrer Anwendung weiterzuleiten.
### Ein Load Balancer โ€“ mehrere Workercontainer
@ -503,9 +521,12 @@ Wenn Sie Container (z. B. Docker, Kubernetes) verwenden, kรถnnen Sie hauptsรคchl
Wenn Sie **mehrere Container** haben, von denen wahrscheinlich jeder einen **einzelnen Prozess** ausfรผhrt (z. B. in einem **Kubernetes**-Cluster), dann mรถchten Sie wahrscheinlich einen **separaten Container** haben, welcher die Arbeit der **Vorab-Schritte** in einem einzelnen Container, mit einem einzelnenen Prozess ausfรผhrt, **bevor** die replizierten Workercontainer ausgefรผhrt werden.
!!! info
/// info
Wenn Sie Kubernetes verwenden, wรคre dies wahrscheinlich ein <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers/" class="external-link" target="_blank">Init-Container</a>.
///
Wenn es in Ihrem Anwendungsfall kein Problem darstellt, diese vorherigen Schritte **mehrmals parallel** auszufรผhren (z. B. wenn Sie keine Datenbankmigrationen ausfรผhren, sondern nur prรผfen, ob die Datenbank bereits bereit ist), kรถnnen Sie sie auch einfach in jedem Container direkt vor dem Start des Hauptprozesses einfรผgen.
### Einzelner Container
@ -520,18 +541,24 @@ Dieses Image wรคre vor allem in den oben beschriebenen Situationen nรผtzlich: [C
* <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
!!! warning "Achtung"
/// warning | "Achtung"
Es besteht eine hohe Wahrscheinlichkeit, dass Sie dieses oder ein รคhnliches Basisimage **nicht** benรถtigen und es besser wรคre, wenn Sie das Image von Grund auf neu erstellen wรผrden, wie [oben beschrieben in: Ein Docker-Image fรผr FastAPI erstellen](#ein-docker-image-fur-fastapi-erstellen).
///
Dieses Image verfรผgt รผber einen **Auto-Tuning**-Mechanismus, um die **Anzahl der Arbeitsprozesse** basierend auf den verfรผgbaren CPU-Kernen festzulegen.
Es verfรผgt รผber **vernรผnftige Standardeinstellungen**, aber Sie kรถnnen trotzdem alle Konfigurationen mit **Umgebungsvariablen** oder Konfigurationsdateien รคndern und aktualisieren.
Es unterstรผtzt auch die Ausfรผhrung von <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker#pre_start_path" class="external-link" target="_blank">**Vorab-Schritten vor dem Start** </a> mit einem Skript.
!!! tip "Tipp"
/// tip | "Tipp"
Um alle Konfigurationen und Optionen anzuzeigen, gehen Sie zur Docker-Image-Seite: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
///
### Anzahl der Prozesse auf dem offiziellen Docker-Image
Die **Anzahl der Prozesse** auf diesem Image wird **automatisch** anhand der verfรผgbaren CPU-**Kerne** berechnet.
@ -657,9 +684,12 @@ CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
11. Fรผhre den Befehl `uvicorn` aus und weise ihn an, das aus `app.main` importierte `app`-Objekt zu verwenden.
!!! tip "Tipp"
/// tip | "Tipp"
Klicken Sie auf die Zahlenblasen, um zu sehen, was jede Zeile bewirkt.
///
Eine **Docker-Phase** ist ein Teil eines `Dockerfile`s, welcher als **temporรคres Containerimage** fungiert und nur zum Generieren einiger Dateien fรผr die spรคtere Verwendung verwendet wird.
Die erste Phase wird nur zur **Installation von Poetry** und zur **Generierung der `requirements.txt`** mit deren Projektabhรคngigkeiten aus der Datei `pyproject.toml` von Poetry verwendet.

15
docs/de/docs/deployment/https.md

@ -4,9 +4,12 @@ Es ist leicht anzunehmen, dass HTTPS etwas ist, was einfach nur โ€žaktiviertโ€œ
Aber es ist viel komplexer als das.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie es eilig haben oder es Ihnen egal ist, fahren Sie mit den nรคchsten Abschnitten fort, um Schritt-fรผr-Schritt-Anleitungen fรผr die Einrichtung der verschiedenen Technologien zu erhalten.
///
Um **die Grundlagen von HTTPS** aus Sicht des Benutzers zu erlernen, schauen Sie sich <a href="https://howhttps.works/" class="external-link" target="_blank">https://howhttps.works/</a> an.
Aus **Sicht des Entwicklers** sollten Sie beim Nachdenken รผber HTTPS Folgendes beachten:
@ -68,9 +71,12 @@ In dem oder den DNS-Server(n) wรผrden Sie einen Eintrag (einen โ€ž`A record`โ€œ)
Sie wรผrden dies wahrscheinlich nur einmal tun, beim ersten Mal, wenn Sie alles einrichten.
!!! tip "Tipp"
/// tip | "Tipp"
Dieser Domainnamen-Aspekt liegt weit vor HTTPS, aber da alles von der Domain und der IP-Adresse abhรคngt, lohnt es sich, das hier zu erwรคhnen.
///
### DNS
Konzentrieren wir uns nun auf alle tatsรคchlichen HTTPS-Aspekte.
@ -115,9 +121,12 @@ Danach verfรผgen der Client und der Server รผber eine **verschlรผsselte TCP-Verb
Und genau das ist **HTTPS**, es ist einfach **HTTP** innerhalb einer **sicheren TLS-Verbindung**, statt einer puren (unverschlรผsselten) TCP-Verbindung.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass die Verschlรผsselung der Kommunikation auf der **TCP-Ebene** und nicht auf der HTTP-Ebene erfolgt.
///
### HTTPS-Request
Da Client und Server (sprich, der Browser und der TLS-Terminierungsproxy) nun รผber eine **verschlรผsselte TCP-Verbindung** verfรผgen, kรถnnen sie die **HTTP-Kommunikation** starten.

26
docs/de/docs/deployment/manually.md

@ -22,7 +22,7 @@ Wenn man sich auf die entfernte Maschine bezieht, wird sie รผblicherweise als **
Sie kรถnnen einen ASGI-kompatiblen Server installieren mit:
=== "Uvicorn"
//// tab | Uvicorn
* <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>, ein blitzschneller ASGI-Server, basierend auf uvloop und httptools.
@ -36,12 +36,17 @@ Sie kรถnnen einen ASGI-kompatiblen Server installieren mit:
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Durch das Hinzufรผgen von `standard` installiert und verwendet Uvicorn einige empfohlene zusรคtzliche Abhรคngigkeiten.
Inklusive `uvloop`, einen hochperformanten Drop-in-Ersatz fรผr `asyncio`, welcher fรผr einen groรŸen Leistungsschub bei der Nebenlรคufigkeit sorgt.
=== "Hypercorn"
///
////
//// tab | Hypercorn
* <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>, ein ASGI-Server, der auch mit HTTP/2 kompatibel ist.
@ -57,11 +62,13 @@ Sie kรถnnen einen ASGI-kompatiblen Server installieren mit:
... oder jeden anderen ASGI-Server.
////
## Das Serverprogramm ausfรผhren
AnschlieรŸend kรถnnen Sie Ihre Anwendung auf die gleiche Weise ausfรผhren, wie Sie es in den Tutorials getan haben, jedoch ohne die Option `--reload`, z. B.:
=== "Uvicorn"
//// tab | Uvicorn
<div class="termy">
@ -73,7 +80,9 @@ AnschlieรŸend kรถnnen Sie Ihre Anwendung auf die gleiche Weise ausfรผhren, wie S
</div>
=== "Hypercorn"
////
//// tab | Hypercorn
<div class="termy">
@ -85,13 +94,18 @@ AnschlieรŸend kรถnnen Sie Ihre Anwendung auf die gleiche Weise ausfรผhren, wie S
</div>
!!! warning "Achtung"
////
/// warning | "Achtung"
Denken Sie daran, die Option `--reload` zu entfernen, wenn Sie diese verwendet haben.
Die Option `--reload` verbraucht viel mehr Ressourcen, ist instabiler, usw.
Sie hilft sehr wรคhrend der **Entwicklung**, aber Sie sollten sie **nicht** in der **Produktion** verwenden.
///
## Hypercorn mit Trio
Starlette und **FastAPI** basieren auf <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, welches diese sowohl mit der Python-Standardbibliothek <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a>, als auch mit <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a> kompatibel macht.

5
docs/de/docs/deployment/server-workers.md

@ -17,11 +17,14 @@ Wie Sie im vorherigen Kapitel รผber [Deployment-Konzepte](concepts.md){.internal
Hier zeige ich Ihnen, wie Sie <a href="https://gunicorn.org/" class="external-link" target="_blank">**Gunicorn**</a> mit **Uvicorn Workerprozessen** verwenden.
!!! info
/// info
Wenn Sie Container verwenden, beispielsweise mit Docker oder Kubernetes, erzรคhle ich Ihnen mehr darรผber im nรคchsten Kapitel: [FastAPI in Containern โ€“ Docker](docker.md){.internal-link target=_blank}.
Insbesondere wenn die Anwendung auf **Kubernetes** lรคuft, werden Sie Gunicorn wahrscheinlich **nicht** verwenden wollen und stattdessen **einen einzelnen Uvicorn-Prozess pro Container** ausfรผhren wollen, aber ich werde Ihnen spรคter in diesem Kapitel mehr darรผber erzรคhlen.
///
## Gunicorn mit Uvicorn-Workern
**Gunicorn** ist hauptsรคchlich ein Anwendungsserver, der den **WSGI-Standard** verwendet. Das bedeutet, dass Gunicorn Anwendungen wie Flask und Django ausliefern kann. Gunicorn selbst ist nicht mit **FastAPI** kompatibel, da FastAPI den neuesten **<a href="https://asgi.readthedocs.io/en/latest/" class="external-link" target="_blank">ASGI-Standard</a>** verwendet.

10
docs/de/docs/deployment/versions.md

@ -42,9 +42,12 @@ GemรครŸ den Konventionen zur semantischen Versionierung kรถnnte jede Version unt
FastAPI folgt auch der Konvention, dass jede โ€žPATCHโ€œ-Versionsรคnderung fรผr Bugfixes und abwรคrtskompatible ร„nderungen gedacht ist.
!!! tip "Tipp"
/// tip | "Tipp"
Der โ€žPATCHโ€œ ist die letzte Zahl, zum Beispiel ist in `0.2.3` die PATCH-Version `3`.
///
Sie sollten also in der Lage sein, eine Version wie folgt anzupinnen:
```txt
@ -53,9 +56,12 @@ fastapi>=0.45.0,<0.46.0
Nicht abwรคrtskompatible ร„nderungen und neue Funktionen werden in โ€žMINORโ€œ-Versionen hinzugefรผgt.
!!! tip "Tipp"
/// tip | "Tipp"
โ€žMINORโ€œ ist die Zahl in der Mitte, zum Beispiel ist in `0.2.3` die MINOR-Version `2`.
///
## Upgrade der FastAPI-Versionen
Sie sollten Tests fรผr Ihre Anwendung hinzufรผgen.

10
docs/de/docs/external-links.md

@ -6,12 +6,18 @@ Es gibt viele Beitrรคge, Artikel, Tools und Projekte zum Thema **FastAPI**.
Hier ist eine unvollstรคndige Liste einiger davon.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie einen Artikel, ein Projekt, ein Tool oder irgendetwas im Zusammenhang mit **FastAPI** haben, was hier noch nicht aufgefรผhrt ist, erstellen Sie einen <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">Pull Request und fรผgen Sie es hinzu</a>.
!!! note "Hinweis Deutsche รœbersetzung"
///
/// note | "Hinweis Deutsche รœbersetzung"
Die folgenden รœberschriften und Links werden aus einer <a href="https://github.com/fastapi/fastapi/blob/master/docs/en/data/external_links.yml" class="external-link" target="_blank">anderen Datei</a> gelesen und sind daher nicht ins Deutsche รผbersetzt.
///
{% for section_name, section_content in external_links.items() %}
## {{ section_name }}

5
docs/de/docs/features.md

@ -64,11 +64,14 @@ second_user_data = {
my_second_user: User = User(**second_user_data)
```
!!! info
/// info
`**second_user_data` bedeutet:
Nimm die Schlรผssel-Wert-Paare des `second_user_data` <abbr title="Dictionary โ€“ Wรถrterbuch: In anderen Programmiersprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dicts</abbr> und รผbergib sie direkt als Schlรผsselwort-Argumente. ร„quivalent zu: `User(id=4, name="Mary", joined="2018-11-30")`.
///
### Editor Unterstรผtzung
Das ganze Framework wurde so entworfen, dass es einfach und intuitiv zu benutzen ist; alle Entscheidungen wurden auf mehreren Editoren getestet, sogar vor der Implementierung, um die bestmรถgliche Entwicklererfahrung zu gewรคhrleisten.

10
docs/de/docs/help-fastapi.md

@ -169,13 +169,16 @@ Und wenn es irgendeinen anderen Stil- oder Konsistenz-Bedarf gibt, bitte ich dir
* Schreiben Sie dann einen **Kommentar** und berichten, dass Sie das getan haben. So weiรŸ ich, dass Sie ihn wirklich รผberprรผft haben.
!!! info
/// info
Leider kann ich PRs, nur weil sie von Mehreren gutgeheiรŸen wurden, nicht einfach vertrauen.
Es ist mehrmals passiert, dass es PRs mit drei, fรผnf oder mehr Zustimmungen gibt, wahrscheinlich weil die Beschreibung ansprechend ist, aber wenn ich die PRs รผberprรผfe, sind sie tatsรคchlich fehlerhaft, haben einen Bug, oder lรถsen das Problem nicht, welches sie behaupten, zu lรถsen. ๐Ÿ˜…
Daher ist es wirklich wichtig, dass Sie den Code tatsรคchlich lesen und ausfรผhren und mir in den Kommentaren mitteilen, dass Sie dies getan haben. ๐Ÿค“
///
* Wenn der PR irgendwie vereinfacht werden kann, fragen Sie ruhig danach, aber seien Sie nicht zu wรคhlerisch, es gibt viele subjektive Standpunkte (und ich habe auch meinen eigenen ๐Ÿ™ˆ), also ist es besser, wenn man sich auf die wesentlichen Dinge konzentriert.
### Tests
@ -225,11 +228,14 @@ Wenn Sie mir dabei helfen kรถnnen, **helfen Sie mir, FastAPI am Laufen zu erhalt
Treten Sie dem ๐Ÿ‘ฅ <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">Discord-Chatserver</a> ๐Ÿ‘ฅ bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie Fragen haben, stellen Sie sie bei <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Diskussionen</a>, es besteht eine viel bessere Chance, dass Sie hier Hilfe von den [FastAPI-Experten](fastapi-people.md#experten){.internal-link target=_blank} erhalten.
Nutzen Sie den Chat nur fรผr andere allgemeine Gesprรคche.
///
### Den Chat nicht fรผr Fragen verwenden
Bedenken Sie, da Chats mehr โ€žfreie Konversationโ€œ ermรถglichen, dass es verlockend ist, Fragen zu stellen, die zu allgemein und schwierig zu beantworten sind, sodass Sie mรถglicherweise keine Antworten erhalten.

10
docs/de/docs/how-to/custom-docs-ui-assets.md

@ -40,13 +40,16 @@ Und genau so fรผr ReDoc ...
{!../../../docs_src/custom_docs_ui/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Die *Pfadoperation* fรผr `swagger_ui_redirect` ist ein Hilfsmittel bei der Verwendung von OAuth2.
Wenn Sie Ihre API mit einem OAuth2-Anbieter integrieren, kรถnnen Sie sich authentifizieren und mit den erworbenen Anmeldeinformationen zur API-Dokumentation zurรผckkehren. Und mit ihr interagieren, die echte OAuth2-Authentifizierung verwendend.
Swagger UI erledigt das hinter den Kulissen fรผr Sie, benรถtigt aber diesen โ€žUmleitungsโ€œ-Helfer.
///
### Eine *Pfadoperation* erstellen, um es zu testen
Um nun testen zu kรถnnen, ob alles funktioniert, erstellen Sie eine *Pfadoperation*:
@ -177,13 +180,16 @@ Und genau so fรผr ReDoc ...
{!../../../docs_src/custom_docs_ui/tutorial002.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Die *Pfadoperation* fรผr `swagger_ui_redirect` ist ein Hilfsmittel bei der Verwendung von OAuth2.
Wenn Sie Ihre API mit einem OAuth2-Anbieter integrieren, kรถnnen Sie sich authentifizieren und mit den erworbenen Anmeldeinformationen zur API-Dokumentation zurรผckkehren. Und mit ihr interagieren, die echte OAuth2-Authentifizierung verwendend.
Swagger UI erledigt das hinter den Kulissen fรผr Sie, benรถtigt aber diesen โ€žUmleitungsโ€œ-Helfer.
///
### Eine *Pfadoperation* erstellen, um statische Dateien zu testen
Um nun testen zu kรถnnen, ob alles funktioniert, erstellen Sie eine *Pfadoperation*:

20
docs/de/docs/how-to/custom-request-and-route.md

@ -6,11 +6,14 @@ Das kann insbesondere eine gute Alternative zur Logik in einer Middleware sein.
Wenn Sie beispielsweise den Requestbody lesen oder manipulieren mรถchten, bevor er von Ihrer Anwendung verarbeitet wird.
!!! danger "Gefahr"
/// danger | "Gefahr"
Dies ist eine โ€žfortgeschritteneโ€œ Funktion.
Wenn Sie gerade erst mit **FastAPI** beginnen, mรถchten Sie diesen Abschnitt vielleicht รผberspringen.
///
## Anwendungsfรคlle
Einige Anwendungsfรคlle sind:
@ -27,9 +30,12 @@ Und eine `APIRoute`-Unterklasse zur Verwendung dieser benutzerdefinierten Reques
### Eine benutzerdefinierte `GzipRequest`-Klasse erstellen
!!! tip "Tipp"
/// tip | "Tipp"
Dies ist nur ein einfaches Beispiel, um zu demonstrieren, wie es funktioniert. Wenn Sie Gzip-Unterstรผtzung benรถtigen, kรถnnen Sie die bereitgestellte [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware){.internal-link target=_blank} verwenden.
///
Zuerst erstellen wir eine `GzipRequest`-Klasse, welche die Methode `Request.body()` รผberschreibt, um den Body bei Vorhandensein eines entsprechenden Headers zu dekomprimieren.
Wenn der Header kein `gzip` enthรคlt, wird nicht versucht, den Body zu dekomprimieren.
@ -54,7 +60,8 @@ Hier verwenden wir sie, um aus dem ursprรผnglichen Request einen `GzipRequest` z
{!../../../docs_src/custom_request_and_route/tutorial001.py!}
```
!!! note "Technische Details"
/// note | "Technische Details"
Ein `Request` hat ein `request.scope`-Attribut, welches einfach ein Python-`dict` ist, welches die mit dem Request verbundenen Metadaten enthรคlt.
Ein `Request` hat auch ein `request.receive`, welches eine Funktion ist, die den Hauptteil des Requests empfรคngt.
@ -65,6 +72,8 @@ Hier verwenden wir sie, um aus dem ursprรผnglichen Request einen `GzipRequest` z
Um mehr รผber den `Request` zu erfahren, schauen Sie sich <a href="https://www.starlette.io/requests/" class="external-link" target="_blank">Starlettes Dokumentation zu Requests</a> an.
///
Das Einzige, was die von `GzipRequest.get_route_handler` zurรผckgegebene Funktion anders macht, ist die Konvertierung von `Request` in ein `GzipRequest`.
Dabei kรผmmert sich unser `GzipRequest` um die Dekomprimierung der Daten (falls erforderlich), bevor diese an unsere *Pfadoperationen* weitergegeben werden.
@ -75,11 +84,14 @@ Aufgrund unserer ร„nderungen in `GzipRequest.body` wird der Requestbody jedoch b
## Zugriff auf den Requestbody in einem Exceptionhandler
!!! tip "Tipp"
/// tip | "Tipp"
Um dasselbe Problem zu lรถsen, ist es wahrscheinlich viel einfacher, den `body` in einem benutzerdefinierten Handler fรผr `RequestValidationError` zu verwenden ([Fehlerbehandlung](../tutorial/handling-errors.md#den-requestvalidationerror-body-verwenden){.internal-link target=_blank}).
Dieses Beispiel ist jedoch immer noch gรผltig und zeigt, wie mit den internen Komponenten interagiert wird.
///
Wir kรถnnen denselben Ansatz auch verwenden, um in einem Exceptionhandler auf den Requestbody zuzugreifen.
Alles, was wir tun mรผssen, ist, den Request innerhalb eines `try`/`except`-Blocks zu handhaben:

5
docs/de/docs/how-to/extending-openapi.md

@ -27,9 +27,12 @@ Und diese Funktion `get_openapi()` erhรคlt als Parameter:
* `description`: Die Beschreibung Ihrer API. Dies kann Markdown enthalten und wird in der Dokumentation angezeigt.
* `routes`: Eine Liste von Routen, dies sind alle registrierten *Pfadoperationen*. Sie stammen von `app.routes`.
!!! info
/// info
Der Parameter `summary` ist in OpenAPI 3.1.0 und hรถher verfรผgbar und wird von FastAPI 0.99.0 und hรถher unterstรผtzt.
///
## รœberschreiben der Standardeinstellungen
Mithilfe der oben genannten Informationen kรถnnen Sie dieselbe Hilfsfunktion verwenden, um das OpenAPI-Schema zu generieren und jeden benรถtigten Teil zu รผberschreiben.

10
docs/de/docs/how-to/graphql.md

@ -4,13 +4,16 @@ Da **FastAPI** auf dem **ASGI**-Standard basiert, ist es sehr einfach, jede **Gr
Sie kรถnnen normale FastAPI-*Pfadoperationen* mit GraphQL in derselben Anwendung kombinieren.
!!! tip "Tipp"
/// tip | "Tipp"
**GraphQL** lรถst einige sehr spezifische Anwendungsfรคlle.
Es hat **Vorteile** und **Nachteile** im Vergleich zu gรคngigen **Web-APIs**.
Wiegen Sie ab, ob die **Vorteile** fรผr Ihren Anwendungsfall die **Nachteile** ausgleichen. ๐Ÿค“
///
## GraphQL-Bibliotheken
Hier sind einige der **GraphQL**-Bibliotheken, welche **ASGI** unterstรผtzen. Diese kรถnnten Sie mit **FastAPI** verwenden:
@ -46,9 +49,12 @@ Frรผhere Versionen von Starlette enthielten eine `GraphQLApp`-Klasse zur Integra
Das wurde von Starlette deprecated, aber wenn Sie Code haben, der das verwendet, kรถnnen Sie einfach zu <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a> **migrieren**, welches denselben Anwendungsfall abdeckt und รผber eine **fast identische Schnittstelle** verfรผgt.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie GraphQL benรถtigen, wรผrde ich Ihnen trotzdem empfehlen, sich <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry</a> anzuschauen, da es auf Typannotationen basiert, statt auf benutzerdefinierten Klassen und Typen.
///
## Mehr darรผber lernen
Weitere Informationen zu **GraphQL** finden Sie in der <a href="https://graphql.org/" class="external-link" target="_blank">offiziellen GraphQL-Dokumentation</a>.

5
docs/de/docs/how-to/index.md

@ -6,5 +6,8 @@ Die meisten dieser Ideen sind mehr oder weniger **unabhรคngig**, und in den meis
Wenn etwas fรผr Ihr Projekt interessant und nรผtzlich erscheint, lesen Sie es, andernfalls รผberspringen Sie es einfach.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie strukturiert **FastAPI lernen** mรถchten (empfohlen), lesen Sie stattdessen Kapitel fรผr Kapitel das [Tutorial โ€“ Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank}.
///

53
docs/de/docs/how-to/separate-openapi-schemas.md

@ -10,7 +10,7 @@ Sehen wir uns an, wie das funktioniert und wie Sie es bei Bedarf รคndern kรถnnen
Nehmen wir an, Sie haben ein Pydantic-Modell mit Defaultwerten wie dieses:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001_py310.py[ln:1-7]!}
@ -27,7 +27,9 @@ Nehmen wir an, Sie haben ein Pydantic-Modell mit Defaultwerten wie dieses:
</details>
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001_py39.py[ln:1-9]!}
@ -44,7 +46,9 @@ Nehmen wir an, Sie haben ein Pydantic-Modell mit Defaultwerten wie dieses:
</details>
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001.py[ln:1-9]!}
@ -61,11 +65,13 @@ Nehmen wir an, Sie haben ein Pydantic-Modell mit Defaultwerten wie dieses:
</details>
////
### Modell fรผr Eingabe
Wenn Sie dieses Modell wie hier als Eingabe verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="14"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001_py310.py[ln:1-15]!}
@ -82,7 +88,9 @@ Wenn Sie dieses Modell wie hier als Eingabe verwenden:
</details>
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="16"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001_py39.py[ln:1-17]!}
@ -99,7 +107,9 @@ Wenn Sie dieses Modell wie hier als Eingabe verwenden:
</details>
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="16"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001.py[ln:1-17]!}
@ -116,6 +126,8 @@ Wenn Sie dieses Modell wie hier als Eingabe verwenden:
</details>
////
... dann ist das Feld `description` **nicht erforderlich**. Weil es den Defaultwert `None` hat.
### Eingabemodell in der Dokumentation
@ -130,24 +142,30 @@ Sie kรถnnen รผberprรผfen, dass das Feld `description` in der Dokumentation kein
Wenn Sie jedoch dasselbe Modell als Ausgabe verwenden, wie hier:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="21"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="21"
{!> ../../../docs_src/separate_openapi_schemas/tutorial001.py!}
```
////
... dann, weil `description` einen Defaultwert hat, wird es, wenn Sie fรผr dieses Feld **nichts zurรผckgeben**, immer noch diesen **Defaultwert** haben.
### Modell fรผr Ausgabe-Responsedaten
@ -199,27 +217,36 @@ Der Hauptanwendungsfall hierfรผr besteht wahrscheinlich darin, dass Sie das mal
In diesem Fall kรถnnen Sie diese Funktion in **FastAPI** mit dem Parameter `separate_input_output_schemas=False` deaktivieren.
!!! info
/// info
Unterstรผtzung fรผr `separate_input_output_schemas` wurde in FastAPI `0.102.0` hinzugefรผgt. ๐Ÿค“
=== "Python 3.10+"
///
//// tab | Python 3.10+
```Python hl_lines="10"
{!> ../../../docs_src/separate_openapi_schemas/tutorial002_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="12"
{!> ../../../docs_src/separate_openapi_schemas/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12"
{!> ../../../docs_src/separate_openapi_schemas/tutorial002.py!}
```
////
### Gleiches Schema fรผr Eingabe- und Ausgabemodelle in der Dokumentation
Und jetzt wird es ein einziges Schema fรผr die Eingabe und Ausgabe des Modells geben, nur `Item`, und es wird `description` als **nicht erforderlich** kennzeichnen:

111
docs/de/docs/python-types.md

@ -12,9 +12,12 @@ Dies ist lediglich eine **schnelle Anleitung / Auffrischung** รผber Pythons Typh
Aber selbst wenn Sie **FastAPI** nie verwenden, wird es fรผr Sie nรผtzlich sein, ein wenig darรผber zu lernen.
!!! note "Hinweis"
/// note | "Hinweis"
Wenn Sie ein Python-Experte sind und bereits alles รผber Typhinweise wissen, รผberspringen Sie dieses Kapitel und fahren Sie mit dem nรคchsten fort.
///
## Motivation
Fangen wir mit einem einfachen Beispiel an:
@ -170,7 +173,7 @@ Wenn Sie รผber die **neueste Version von Python** verfรผgen, verwenden Sie die B
Definieren wir zum Beispiel eine Variable, die eine `list` von `str` โ€“ eine Liste von Strings โ€“ sein soll.
=== "Python 3.9+"
//// tab | Python 3.9+
Deklarieren Sie die Variable mit der gleichen Doppelpunkt-Syntax (`:`).
@ -182,7 +185,9 @@ Definieren wir zum Beispiel eine Variable, die eine `list` von `str` โ€“ eine Li
{!> ../../../docs_src/python_types/tutorial006_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
Von `typing` importieren Sie `List` (mit GroรŸbuchstaben `L`):
@ -200,16 +205,24 @@ Definieren wir zum Beispiel eine Variable, die eine `list` von `str` โ€“ eine Li
{!> ../../../docs_src/python_types/tutorial006.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Die inneren Typen in den eckigen Klammern werden als โ€žTyp-Parameterโ€œ bezeichnet.
In diesem Fall ist `str` der Typ-Parameter, der an `List` รผbergeben wird (oder `list` in Python 3.9 und darรผber).
///
Das bedeutet: Die Variable `items` ist eine Liste โ€“ `list` โ€“ und jedes der Elemente in dieser Liste ist ein String โ€“ `str`.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie Python 3.9 oder hรถher verwenden, mรผssen Sie `List` nicht von `typing` importieren, Sie kรถnnen stattdessen den regulรคren `list`-Typ verwenden.
///
Auf diese Weise kann Ihr Editor Sie auch bei der Bearbeitung von Eintrรคgen aus der Liste unterstรผtzen:
<img src="/img/python-types/image05.png">
@ -224,18 +237,22 @@ Und trotzdem weiรŸ der Editor, dass es sich um ein `str` handelt, und bietet ent
Das Gleiche gilt fรผr die Deklaration eines Tupels โ€“ `tuple` โ€“ und einer Menge โ€“ `set`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial007_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial007.py!}
```
////
Das bedeutet:
* Die Variable `items_t` ist ein `tuple` mit 3 Elementen, einem `int`, einem weiteren `int` und einem `str`.
@ -249,18 +266,22 @@ Der erste Typ-Parameter ist fรผr die Schlรผssel des `dict`.
Der zweite Typ-Parameter ist fรผr die Werte des `dict`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial008_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial008.py!}
```
////
Das bedeutet:
* Die Variable `prices` ist ein `dict`:
@ -275,18 +296,22 @@ In Python 3.6 und hรถher (inklusive Python 3.10) kรถnnen Sie den `Union`-Typ von
In Python 3.10 gibt es zusรคtzlich eine **neue Syntax**, die es erlaubt, die mรถglichen Typen getrennt von einem <abbr title='Allgemein: โ€žoderโ€œ. In anderem Zusammenhang auch โ€žBitweises ODERโ€œ, aber letztere Bedeutung ist hier nicht relevant'>vertikalen Balken (`|`)</abbr> aufzulisten.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial008b_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial008b.py!}
```
////
In beiden Fรคllen bedeutet das, dass `item` ein `int` oder ein `str` sein kann.
#### Vielleicht `None`
@ -305,24 +330,30 @@ Wenn Sie `Optional[str]` anstelle von nur `str` verwenden, wird Ihr Editor Ihnen
Das bedeutet auch, dass Sie in Python 3.10 `Something | None` verwenden kรถnnen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1"
{!> ../../../docs_src/python_types/tutorial009_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial009.py!}
```
=== "Python 3.8+ Alternative"
////
//// tab | Python 3.8+ Alternative
```Python hl_lines="1 4"
{!> ../../../docs_src/python_types/tutorial009b.py!}
```
////
#### `Union` oder `Optional` verwenden?
Wenn Sie eine Python-Version unterhalb 3.10 verwenden, hier ist mein sehr **subjektiver** Standpunkt dazu:
@ -366,7 +397,7 @@ Und dann mรผssen Sie sich nicht mehr um Namen wie `Optional` und `Union` kรผmmer
Diese Typen, die Typ-Parameter in eckigen Klammern akzeptieren, werden **generische Typen** oder **Generics** genannt.
=== "Python 3.10+"
//// tab | Python 3.10+
Sie kรถnnen die eingebauten Typen als Generics verwenden (mit eckigen Klammern und Typen darin):
@ -383,7 +414,9 @@ Diese Typen, die Typ-Parameter in eckigen Klammern akzeptieren, werden **generis
In Python 3.10 kรถnnen Sie als Alternative zu den Generics `Union` und `Optional` den <abbr title='Allgemein: โ€žoderโ€œ. In anderem Zusammenhang auch โ€žBitweises ODERโ€œ, aber letztere Bedeutung ist hier nicht relevant'>vertikalen Balken (`|`)</abbr> verwenden, um Vereinigungen von Typen zu deklarieren, das ist besser und einfacher.
=== "Python 3.9+"
////
//// tab | Python 3.9+
Sie kรถnnen die eingebauten Typen als Generics verwenden (mit eckigen Klammern und Typen darin):
@ -398,7 +431,9 @@ Diese Typen, die Typ-Parameter in eckigen Klammern akzeptieren, werden **generis
* `Optional`
* ... und andere.
=== "Python 3.8+"
////
//// tab | Python 3.8+
* `List`
* `Tuple`
@ -408,6 +443,8 @@ Diese Typen, die Typ-Parameter in eckigen Klammern akzeptieren, werden **generis
* `Optional`
* ... und andere.
////
### Klassen als Typen
Sie kรถnnen auch eine Klasse als Typ einer Variablen deklarieren.
@ -446,39 +483,51 @@ Und Sie erhalten volle Editor-Unterstรผtzung fรผr dieses Objekt.
Ein Beispiel aus der offiziellen Pydantic Dokumentation:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python
{!> ../../../docs_src/python_types/tutorial011_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python
{!> ../../../docs_src/python_types/tutorial011_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python
{!> ../../../docs_src/python_types/tutorial011.py!}
```
!!! info
////
/// info
Um mehr รผber <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic zu erfahren, schauen Sie sich dessen Dokumentation an</a>.
///
**FastAPI** basiert vollstรคndig auf Pydantic.
Viel mehr von all dem werden Sie in praktischer Anwendung im [Tutorial - Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank} sehen.
!!! tip "Tipp"
/// tip | "Tipp"
Pydantic verhรคlt sich speziell, wenn Sie `Optional` oder `Union[Etwas, None]` ohne einen Default-Wert verwenden. Sie kรถnnen darรผber in der Pydantic Dokumentation unter <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Required fields</a> mehr erfahren.
///
## Typhinweise mit Metadaten-Annotationen
Python bietet auch die Mรถglichkeit, **zusรคtzliche Metadaten** in Typhinweisen unterzubringen, mittels `Annotated`.
=== "Python 3.9+"
//// tab | Python 3.9+
In Python 3.9 ist `Annotated` ein Teil der Standardbibliothek, Sie kรถnnen es von `typing` importieren.
@ -486,7 +535,9 @@ Python bietet auch die Mรถglichkeit, **zusรคtzliche Metadaten** in Typhinweisen
{!> ../../../docs_src/python_types/tutorial013_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
In Versionen niedriger als Python 3.9 importieren Sie `Annotated` von `typing_extensions`.
@ -496,6 +547,8 @@ Python bietet auch die Mรถglichkeit, **zusรคtzliche Metadaten** in Typhinweisen
{!> ../../../docs_src/python_types/tutorial013.py!}
```
////
Python selbst macht nichts mit `Annotated`. Fรผr Editoren und andere Tools ist der Typ immer noch `str`.
Aber Sie kรถnnen `Annotated` nutzen, um **FastAPI** mit Metadaten zu versorgen, die ihm sagen, wie sich ihre Anwendung verhalten soll.
@ -506,11 +559,14 @@ Im Moment mรผssen Sie nur wissen, dass `Annotated` existiert, und dass es Standa
Spรคter werden Sie sehen, wie **mรคchtig** es sein kann.
!!! tip "Tipp"
/// tip | "Tipp"
Der Umstand, dass es **Standard-Python** ist, bedeutet, dass Sie immer noch die **bestmรถgliche Entwickler-Erfahrung** in ihrem Editor haben, sowie mit den Tools, die Sie nutzen, um ihren Code zu analysieren, zu refaktorisieren, usw. โœจ
Und ebenfalls, dass Ihr Code sehr kompatibel mit vielen anderen Python-Tools und -Bibliotheken sein wird. ๐Ÿš€
///
## Typhinweise in **FastAPI**
**FastAPI** macht sich diese Typhinweise zunutze, um mehrere Dinge zu tun.
@ -533,5 +589,8 @@ Das mag alles abstrakt klingen. Machen Sie sich keine Sorgen. Sie werden all das
Das Wichtigste ist, dass **FastAPI** durch die Verwendung von Standard-Python-Typen an einer einzigen Stelle (anstatt weitere Klassen, Dekoratoren usw. hinzuzufรผgen) einen GroรŸteil der Arbeit fรผr Sie erledigt.
!!! info
/// info
Wenn Sie bereits das ganze Tutorial durchgearbeitet haben und mehr รผber Typen erfahren wollen, dann ist eine gute Ressource <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">der โ€žCheat Sheetโ€œ von `mypy`</a>.
///

5
docs/de/docs/reference/index.md

@ -4,5 +4,8 @@ Hier ist die Referenz oder Code-API, die Klassen, Funktionen, Parameter, Attribu
Wenn Sie **FastAPI** lernen mรถchten, ist es viel besser, das [FastAPI-Tutorial](https://fastapi.tiangolo.com/tutorial/) zu lesen.
!!! note "Hinweis Deutsche รœbersetzung"
/// note | "Hinweis Deutsche รœbersetzung"
Die nachfolgende API wird aus der Quelltext-Dokumentation erstellt, daher sind nur die Einleitungen auf Deutsch.
///

5
docs/de/docs/reference/request.md

@ -8,7 +8,10 @@ Sie kรถnnen es direkt von `fastapi` importieren:
from fastapi import Request
```
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie Abhรคngigkeiten definieren mรถchten, die sowohl mit HTTP als auch mit WebSockets kompatibel sein sollen, kรถnnen Sie einen Parameter definieren, der eine `HTTPConnection` anstelle eines `Request` oder eines `WebSocket` akzeptiert.
///
::: fastapi.Request

5
docs/de/docs/reference/websockets.md

@ -6,9 +6,12 @@ Bei der Definition von WebSockets deklarieren Sie normalerweise einen Parameter
from fastapi import WebSocket
```
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie Abhรคngigkeiten definieren mรถchten, die sowohl mit HTTP als auch mit WebSockets kompatibel sein sollen, kรถnnen Sie einen Parameter definieren, der eine `HTTPConnection` anstelle eines `Request` oder eines `WebSocket` akzeptiert.
///
::: fastapi.WebSocket
options:
members:

30
docs/de/docs/tutorial/background-tasks.md

@ -57,42 +57,58 @@ Die Verwendung von `BackgroundTasks` funktioniert auch mit dem <abbr title="Einb
**FastAPI** weiรŸ, was jeweils zu tun ist und wie dasselbe Objekt wiederverwendet werden kann, sodass alle Hintergrundtasks zusammengefรผhrt und anschlieรŸend im Hintergrund ausgefรผhrt werden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="13 15 22 25"
{!> ../../../docs_src/background_tasks/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="13 15 22 25"
{!> ../../../docs_src/background_tasks/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="14 16 23 26"
{!> ../../../docs_src/background_tasks/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11 13 20 23"
{!> ../../../docs_src/background_tasks/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="13 15 22 25"
{!> ../../../docs_src/background_tasks/tutorial002.py!}
```
////
In obigem Beispiel werden die Nachrichten, *nachdem* die Response gesendet wurde, in die Datei `log.txt` geschrieben.
Wenn im Request ein Query-Parameter enthalten war, wird dieser in einem Hintergrundtask in das Log geschrieben.

87
docs/de/docs/tutorial/bigger-applications.md

@ -4,9 +4,12 @@ Wenn Sie eine Anwendung oder eine Web-API erstellen, ist es selten der Fall, das
**FastAPI** bietet ein praktisches Werkzeug zur Strukturierung Ihrer Anwendung bei gleichzeitiger Wahrung der Flexibilitรคt.
!!! info
/// info
Wenn Sie von Flask kommen, wรคre dies das ร„quivalent zu Flasks Blueprints.
///
## Eine Beispiel-Dateistruktur
Nehmen wir an, Sie haben eine Dateistruktur wie diese:
@ -26,7 +29,8 @@ Nehmen wir an, Sie haben eine Dateistruktur wie diese:
โ”‚ย ย  โ””โ”€โ”€ admin.py
```
!!! tip "Tipp"
/// tip | "Tipp"
Es gibt mehrere `__init__.py`-Dateien: eine in jedem Verzeichnis oder Unterverzeichnis.
Das ermรถglicht den Import von Code aus einer Datei in eine andere.
@ -37,6 +41,8 @@ Nehmen wir an, Sie haben eine Dateistruktur wie diese:
from app.routers import items
```
///
* Das Verzeichnis `app` enthรคlt alles. Und es hat eine leere Datei `app/__init__.py`, es handelt sich also um ein โ€žPython-Packageโ€œ (eine Sammlung von โ€žPython-Modulenโ€œ): `app`.
* Es enthรคlt eine Datei `app/main.py`. Da sie sich in einem Python-Package (einem Verzeichnis mit einer Datei `__init__.py`) befindet, ist sie ein โ€žModulโ€œ dieses Packages: `app.main`.
* Es gibt auch eine Datei `app/dependencies.py`, genau wie `app/main.py` ist sie ein โ€žModulโ€œ: `app.dependencies`.
@ -99,9 +105,12 @@ Alle die gleichen Optionen werden unterstรผtzt.
Alle die gleichen `parameters`, `responses`, `dependencies`, `tags`, usw.
!!! tip "Tipp"
/// tip | "Tipp"
In diesem Beispiel heiรŸt die Variable `router`, aber Sie kรถnnen ihr einen beliebigen Namen geben.
///
Wir werden diesen `APIRouter` in die Hauptanwendung `FastAPI` einbinden, aber zuerst kรผmmern wir uns um die Abhรคngigkeiten und einen anderen `APIRouter`.
## Abhรคngigkeiten
@ -112,32 +121,44 @@ Also fรผgen wir sie in ihr eigenes `dependencies`-Modul (`app/dependencies.py`)
Wir werden nun eine einfache Abhรคngigkeit verwenden, um einen benutzerdefinierten `X-Token`-Header zu lesen:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="3 6-8" title="app/dependencies.py"
{!> ../../../docs_src/bigger_applications/app_an_py39/dependencies.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 5-7" title="app/dependencies.py"
{!> ../../../docs_src/bigger_applications/app_an/dependencies.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1 4-6" title="app/dependencies.py"
{!> ../../../docs_src/bigger_applications/app/dependencies.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Um dieses Beispiel zu vereinfachen, verwenden wir einen erfundenen Header.
Aber in der Praxis werden Sie mit den integrierten [Sicherheits-Werkzeugen](security/index.md){.internal-link target=_blank} bessere Ergebnisse erzielen.
///
## Ein weiteres Modul mit `APIRouter`.
Nehmen wir an, Sie haben im Modul unter `app/routers/items.py` auch die Endpunkte, die fรผr die Verarbeitung von Artikeln (โ€žItemsโ€œ) aus Ihrer Anwendung vorgesehen sind.
@ -180,9 +201,12 @@ Wir kรถnnen auch eine Liste von `tags` und zusรคtzliche `responses` hinzufรผgen,
Und wir kรถnnen eine Liste von `dependencies` hinzufรผgen, die allen *Pfadoperationen* im Router hinzugefรผgt und fรผr jeden an sie gerichteten Request ausgefรผhrt/aufgelรถst werden.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass รคhnlich wie bei [Abhรคngigkeiten in *Pfadoperation-Dekoratoren*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} kein Wert an Ihre *Pfadoperation-Funktion* รผbergeben wird.
///
Das Endergebnis ist, dass die Pfade fรผr diese Artikel jetzt wie folgt lauten:
* `/items/`
@ -198,12 +222,18 @@ Das Endergebnis ist, dass die Pfade fรผr diese Artikel jetzt wie folgt lauten:
* Zuerst werden die Router-Abhรคngigkeiten ausgefรผhrt, dann die [`dependencies` im Dekorator](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} und dann die normalen Parameterabhรคngigkeiten.
* Sie kรถnnen auch [`Security`-Abhรคngigkeiten mit `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank} hinzufรผgen.
!!! tip "Tipp"
/// tip | "Tipp"
`dependencies` im `APIRouter` kรถnnen beispielsweise verwendet werden, um eine Authentifizierung fรผr eine ganze Gruppe von *Pfadoperationen* zu erfordern. Selbst wenn die Abhรคngigkeiten nicht jeder einzeln hinzugefรผgt werden.
!!! check
///
/// check
Die Parameter `prefix`, `tags`, `responses` und `dependencies` sind (wie in vielen anderen Fรคllen) nur ein Feature von **FastAPI**, um Ihnen dabei zu helfen, Codeverdoppelung zu vermeiden.
///
### Die Abhรคngigkeiten importieren
Der folgende Code befindet sich im Modul `app.routers.items`, also in der Datei `app/routers/items.py`.
@ -218,9 +248,12 @@ Daher verwenden wir einen relativen Import mit `..` fรผr die Abhรคngigkeiten:
#### Wie relative Importe funktionieren
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie genau wissen, wie Importe funktionieren, fahren Sie mit dem nรคchsten Abschnitt unten fort.
///
Ein einzelner Punkt `.`, wie in:
```Python
@ -286,11 +319,14 @@ Aber wir kรถnnen immer noch _mehr_ `tags` hinzufรผgen, die auf eine bestimmte *P
{!../../../docs_src/bigger_applications/app/routers/items.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Diese letzte Pfadoperation wird eine Kombination von Tags haben: `["items", "custom"]`.
Und sie wird auch beide Responses in der Dokumentation haben, eine fรผr `404` und eine fรผr `403`.
///
## Das Haupt-`FastAPI`.
Sehen wir uns nun das Modul unter `app/main.py` an.
@ -345,7 +381,8 @@ Wir kรถnnten sie auch wie folgt importieren:
from app.routers import items, users
```
!!! info
/// info
Die erste Version ist ein โ€žrelativer Importโ€œ:
```Python
@ -360,6 +397,8 @@ from app.routers import items, users
Um mehr รผber Python-Packages und -Module zu erfahren, lesen Sie <a href="https://docs.python.org/3/tutorial/modules.html" class="external-link" target="_blank">die offizielle Python-Dokumentation รผber Module</a>.
///
### Namenskollisionen vermeiden
Wir importieren das Submodul `items` direkt, anstatt nur seine Variable `router` zu importieren.
@ -390,27 +429,36 @@ Inkludieren wir nun die `router` aus diesen Submodulen `users` und `items`:
{!../../../docs_src/bigger_applications/app/main.py!}
```
!!! info
/// info
`users.router` enthรคlt den `APIRouter` in der Datei `app/routers/users.py`.
Und `items.router` enthรคlt den `APIRouter` in der Datei `app/routers/items.py`.
///
Mit `app.include_router()` kรถnnen wir jeden `APIRouter` zur Hauptanwendung `FastAPI` hinzufรผgen.
Es wird alle Routen von diesem Router als Teil von dieser inkludieren.
!!! note "Technische Details"
/// note | "Technische Details"
Tatsรคchlich wird intern eine *Pfadoperation* fรผr jede *Pfadoperation* erstellt, die im `APIRouter` deklariert wurde.
Hinter den Kulissen wird es also tatsรคchlich so funktionieren, als ob alles dieselbe einzige Anwendung wรคre.
!!! check
///
/// check
Bei der Einbindung von Routern mรผssen Sie sich keine Gedanken รผber die Performanz machen.
Dies dauert Mikrosekunden und geschieht nur beim Start.
Es hat also keinen Einfluss auf die Leistung. โšก
///
### Einen `APIRouter` mit benutzerdefinierten `prefix`, `tags`, `responses` und `dependencies` einfรผgen
Stellen wir uns nun vor, dass Ihre Organisation Ihnen die Datei `app/internal/admin.py` gegeben hat.
@ -456,7 +504,8 @@ Hier machen wir es ... nur um zu zeigen, dass wir es kรถnnen ๐Ÿคท:
und es wird korrekt funktionieren, zusammen mit allen anderen *Pfadoperationen*, die mit `app.include_router()` hinzugefรผgt wurden.
!!! info "Sehr technische Details"
/// info | "Sehr technische Details"
**Hinweis**: Dies ist ein sehr technisches Detail, das Sie wahrscheinlich **einfach รผberspringen** kรถnnen.
---
@ -467,6 +516,8 @@ und es wird korrekt funktionieren, zusammen mit allen anderen *Pfadoperationen*,
Da wir sie nicht einfach isolieren und unabhรคngig vom Rest โ€žmountenโ€œ kรถnnen, werden die *Pfadoperationen* โ€žgeklontโ€œ (neu erstellt) und nicht direkt einbezogen.
///
## Es in der automatischen API-Dokumentation ansehen
Fรผhren Sie nun `uvicorn` aus, indem Sie das Modul `app.main` und die Variable `app` verwenden:

80
docs/de/docs/tutorial/body-fields.md

@ -6,88 +6,124 @@ So wie Sie zusรคtzliche Validation und Metadaten in Parametern der **Pfadoperati
Importieren Sie es zuerst:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="4"
{!> ../../../docs_src/body_fields/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="4"
{!> ../../../docs_src/body_fields/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4"
{!> ../../../docs_src/body_fields/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="2"
{!> ../../../docs_src/body_fields/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="4"
{!> ../../../docs_src/body_fields/tutorial001.py!}
```
!!! warning "Achtung"
////
/// warning | "Achtung"
Beachten Sie, dass `Field` direkt von `pydantic` importiert wird, nicht von `fastapi`, wie die anderen (`Query`, `Path`, `Body`, usw.)
///
## Modellattribute deklarieren
Dann kรถnnen Sie `Field` mit Modellattributen deklarieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="11-14"
{!> ../../../docs_src/body_fields/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="11-14"
{!> ../../../docs_src/body_fields/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12-15"
{!> ../../../docs_src/body_fields/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9-12"
{!> ../../../docs_src/body_fields/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11-14"
{!> ../../../docs_src/body_fields/tutorial001.py!}
```
////
`Field` funktioniert genauso wie `Query`, `Path` und `Body`, es hat die gleichen Parameter, usw.
!!! note "Technische Details"
/// note | "Technische Details"
Tatsรคchlich erstellen `Query`, `Path` und andere, die sie kennenlernen werden, Instanzen von Unterklassen einer allgemeinen Klasse `Param`, die ihrerseits eine Unterklasse von Pydantics `FieldInfo`-Klasse ist.
Und Pydantics `Field` gibt ebenfalls eine Instanz von `FieldInfo` zurรผck.
@ -96,18 +132,26 @@ Dann kรถnnen Sie `Field` mit Modellattributen deklarieren:
Denken Sie daran, dass `Query`, `Path` und andere von `fastapi` tatsรคchlich Funktionen sind, die spezielle Klassen zurรผckgeben.
!!! tip "Tipp"
///
/// tip | "Tipp"
Beachten Sie, dass jedes Modellattribut mit einem Typ, Defaultwert und `Field` die gleiche Struktur hat wie ein Parameter einer Pfadoperation-Funktion, nur mit `Field` statt `Path`, `Query`, `Body`.
///
## Zusรคtzliche Information hinzufรผgen
Sie kรถnnen zusรคtzliche Information in `Field`, `Query`, `Body`, usw. deklarieren. Und es wird im generierten JSON-Schema untergebracht.
Sie werden spรคter mehr darรผber lernen, wie man zusรคtzliche Information unterbringt, wenn Sie lernen, Beispiele zu deklarieren.
!!! warning "Achtung"
/// warning | "Achtung"
Extra-Schlรผssel, die `Field` รผberreicht werden, werden auch im resultierenden OpenAPI-Schema Ihrer Anwendung gelistet. Da diese Schlรผssel nicht notwendigerweise Teil der OpenAPI-Spezifikation sind, kรถnnten einige OpenAPI-Tools, wie etwa [der OpenAPI-Validator](https://validator.swagger.io/), nicht mit Ihrem generierten Schema funktionieren.
///
## Zusammenfassung
Sie kรถnnen Pydantics `Field` verwenden, um zusรคtzliche Validierungen und Metadaten fรผr Modellattribute zu deklarieren.

143
docs/de/docs/tutorial/body-multiple-params.md

@ -8,45 +8,64 @@ Zuerst einmal, Sie kรถnnen `Path`-, `Query`- und Requestbody-Parameter-Deklarati
Und Sie kรถnnen auch Body-Parameter als optional kennzeichnen, indem Sie den Defaultwert auf `None` setzen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="18-20"
{!> ../../../docs_src/body_multiple_params/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="18-20"
{!> ../../../docs_src/body_multiple_params/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="19-21"
{!> ../../../docs_src/body_multiple_params/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17-19"
{!> ../../../docs_src/body_multiple_params/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19-21"
{!> ../../../docs_src/body_multiple_params/tutorial001.py!}
```
!!! note "Hinweis"
////
/// note | "Hinweis"
Beachten Sie, dass in diesem Fall das `item`, welches vom Body genommen wird, optional ist. Da es `None` als Defaultwert hat.
///
## Mehrere Body-Parameter
Im vorherigen Beispiel erwartete die *Pfadoperation* einen JSON-Body mit den Attributen eines `Item`s, etwa:
@ -62,18 +81,22 @@ Im vorherigen Beispiel erwartete die *Pfadoperation* einen JSON-Body mit den Att
Aber Sie kรถnnen auch mehrere Body-Parameter deklarieren, z. B. `item` und `user`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="20"
{!> ../../../docs_src/body_multiple_params/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="22"
{!> ../../../docs_src/body_multiple_params/tutorial002.py!}
```
////
In diesem Fall wird **FastAPI** bemerken, dass es mehr als einen Body-Parameter in der Funktion gibt (zwei Parameter, die Pydantic-Modelle sind).
Es wird deshalb die Parameternamen als Schlรผssel (Feldnamen) im Body verwenden, und erwartet einen Body wie folgt:
@ -93,9 +116,12 @@ Es wird deshalb die Parameternamen als Schlรผssel (Feldnamen) im Body verwenden,
}
```
!!! note "Hinweis"
/// note | "Hinweis"
Beachten Sie, dass, obwohl `item` wie zuvor deklariert wurde, es nun unter einem Schlรผssel `item` im Body erwartet wird.
///
**FastAPI** wird die automatische Konvertierung des Requests รผbernehmen, sodass der Parameter `item` seinen spezifischen Inhalt bekommt, genau so wie der Parameter `user`.
Es wird die Validierung dieser zusammengesetzten Daten รผbernehmen, und sie im OpenAPI-Schema und der automatischen Dokumentation dokumentieren.
@ -110,42 +136,58 @@ Wenn Sie diesen Parameter einfach so hinzufรผgen, wird **FastAPI** annehmen, das
Aber Sie kรถnnen **FastAPI** instruieren, ihn als weiteren Body-Schlรผssel zu erkennen, indem Sie `Body` verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="23"
{!> ../../../docs_src/body_multiple_params/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="23"
{!> ../../../docs_src/body_multiple_params/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="24"
{!> ../../../docs_src/body_multiple_params/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="20"
{!> ../../../docs_src/body_multiple_params/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="22"
{!> ../../../docs_src/body_multiple_params/tutorial003.py!}
```
////
In diesem Fall erwartet **FastAPI** einen Body wie:
```JSON
@ -184,45 +226,64 @@ q: str | None = None
Zum Beispiel:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="27"
{!> ../../../docs_src/body_multiple_params/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="27"
{!> ../../../docs_src/body_multiple_params/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="28"
{!> ../../../docs_src/body_multiple_params/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="25"
{!> ../../../docs_src/body_multiple_params/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="27"
{!> ../../../docs_src/body_multiple_params/tutorial004.py!}
```
!!! info
////
/// info
`Body` hat die gleichen zusรคtzlichen Validierungs- und Metadaten-Parameter wie `Query` und `Path` und andere, die Sie spรคter kennenlernen.
///
## Einen einzelnen Body-Parameter einbetten
Nehmen wir an, Sie haben nur einen einzelnen `item`-Body-Parameter, ein Pydantic-Modell `Item`.
@ -237,42 +298,58 @@ item: Item = Body(embed=True)
so wie in:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="17"
{!> ../../../docs_src/body_multiple_params/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="17"
{!> ../../../docs_src/body_multiple_params/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="18"
{!> ../../../docs_src/body_multiple_params/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="15"
{!> ../../../docs_src/body_multiple_params/tutorial005_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17"
{!> ../../../docs_src/body_multiple_params/tutorial005.py!}
```
////
In diesem Fall erwartet **FastAPI** einen Body wie:
```JSON hl_lines="2"

123
docs/de/docs/tutorial/body-nested-models.md

@ -6,18 +6,22 @@ Mit **FastAPI** kรถnnen Sie (dank Pydantic) beliebig tief verschachtelte Modelle
Sie kรถnnen ein Attribut als Kindtyp definieren, zum Beispiel eine Python-`list`e.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="12"
{!> ../../../docs_src/body_nested_models/tutorial001_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="14"
{!> ../../../docs_src/body_nested_models/tutorial001.py!}
```
////
Das bewirkt, dass `tags` eine Liste ist, wenngleich es nichts รผber den Typ der Elemente der Liste aussagt.
## Listen mit Typ-Parametern als Felder
@ -61,24 +65,30 @@ Verwenden Sie dieselbe Standardsyntax fรผr Modellattribute mit inneren Typen.
In unserem Beispiel kรถnnen wir also bewirken, dass `tags` spezifisch eine โ€žListe von Stringsโ€œ ist:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="12"
{!> ../../../docs_src/body_nested_models/tutorial002_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="14"
{!> ../../../docs_src/body_nested_models/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="14"
{!> ../../../docs_src/body_nested_models/tutorial002.py!}
```
////
## Set-Typen
Aber dann denken wir darรผber nach und stellen fest, dass sich die Tags nicht wiederholen sollen, es sollen eindeutige Strings sein.
@ -87,24 +97,30 @@ Python hat einen Datentyp speziell fรผr Mengen eindeutiger Dinge: das <abbr titl
Deklarieren wir also `tags` als Set von Strings.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="12"
{!> ../../../docs_src/body_nested_models/tutorial003_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="14"
{!> ../../../docs_src/body_nested_models/tutorial003_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 14"
{!> ../../../docs_src/body_nested_models/tutorial003.py!}
```
////
Jetzt, selbst wenn Sie einen Request mit duplizierten Daten erhalten, werden diese zu einem Set eindeutiger Dinge konvertiert.
Und wann immer Sie diese Daten ausgeben, selbst wenn die Quelle Duplikate hatte, wird es als Set von eindeutigen Dingen ausgegeben.
@ -125,46 +141,58 @@ Alles das beliebig tief verschachtelt.
Wir kรถnnen zum Beispiel ein `Image`-Modell definieren.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7-9"
{!> ../../../docs_src/body_nested_models/tutorial004_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9-11"
{!> ../../../docs_src/body_nested_models/tutorial004_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9-11"
{!> ../../../docs_src/body_nested_models/tutorial004.py!}
```
////
### Das Kindmodell als Typ verwenden
Und dann kรถnnen wir es als Typ eines Attributes verwenden.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="18"
{!> ../../../docs_src/body_nested_models/tutorial004_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="20"
{!> ../../../docs_src/body_nested_models/tutorial004_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20"
{!> ../../../docs_src/body_nested_models/tutorial004.py!}
```
////
Das wรผrde bedeuten, dass **FastAPI** einen Body erwartet wie:
```JSON
@ -196,48 +224,60 @@ Um alle Optionen kennenzulernen, die Sie haben, schauen Sie sich <a href="https:
Da wir zum Beispiel im `Image`-Modell ein Feld `url` haben, kรถnnen wir deklarieren, dass das eine Instanz von Pydantics `HttpUrl` sein soll, anstelle eines `str`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="2 8"
{!> ../../../docs_src/body_nested_models/tutorial005_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="4 10"
{!> ../../../docs_src/body_nested_models/tutorial005_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4 10"
{!> ../../../docs_src/body_nested_models/tutorial005.py!}
```
////
Es wird getestet, ob der String eine gรผltige URL ist, und als solche wird er in JSON Schema / OpenAPI dokumentiert.
## Attribute mit Listen von Kindmodellen
Sie kรถnnen Pydantic-Modelle auch als Typen innerhalb von `list`, `set`, usw. verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="18"
{!> ../../../docs_src/body_nested_models/tutorial006_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="20"
{!> ../../../docs_src/body_nested_models/tutorial006_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20"
{!> ../../../docs_src/body_nested_models/tutorial006.py!}
```
////
Das wird einen JSON-Body erwarten (konvertieren, validieren, dokumentieren), wie:
```JSON hl_lines="11"
@ -264,34 +304,46 @@ Das wird einen JSON-Body erwarten (konvertieren, validieren, dokumentieren), wie
}
```
!!! info
/// info
Beachten Sie, dass der `images`-Schlรผssel jetzt eine Liste von Bild-Objekten hat.
///
## Tief verschachtelte Modelle
Sie kรถnnen beliebig tief verschachtelte Modelle definieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7 12 18 21 25"
{!> ../../../docs_src/body_nested_models/tutorial007_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9 14 20 23 27"
{!> ../../../docs_src/body_nested_models/tutorial007_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9 14 20 23 27"
{!> ../../../docs_src/body_nested_models/tutorial007.py!}
```
!!! info
////
/// info
Beachten Sie, wie `Offer` eine Liste von `Item`s hat, von denen jedes seinerseits eine optionale Liste von `Image`s hat.
///
## Bodys aus reinen Listen
Wenn Sie mรถchten, dass das รคuรŸerste Element des JSON-Bodys ein JSON-`array` (eine Python-`list`e) ist, kรถnnen Sie den Typ im Funktionsparameter deklarieren, mit der gleichen Syntax wie in Pydantic-Modellen:
@ -308,18 +360,22 @@ images: list[Image]
so wie in:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="13"
{!> ../../../docs_src/body_nested_models/tutorial008_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="15"
{!> ../../../docs_src/body_nested_models/tutorial008.py!}
```
////
## Editor-Unterstรผtzung รผberall
Und Sie erhalten Editor-Unterstรผtzung รผberall.
@ -348,19 +404,24 @@ Das schauen wir uns mal an.
Im folgenden Beispiel akzeptieren Sie irgendein `dict`, solange es `int`-Schlรผssel und `float`-Werte hat.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="7"
{!> ../../../docs_src/body_nested_models/tutorial009_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/body_nested_models/tutorial009.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Bedenken Sie, dass JSON nur `str` als Schlรผssel unterstรผtzt.
Aber Pydantic hat automatische Datenkonvertierung.
@ -369,6 +430,8 @@ Im folgenden Beispiel akzeptieren Sie irgendein `dict`, solange es `int`-Schlรผs
Und das `dict` welches Sie als `weights` erhalten, wird `int`-Schlรผssel und `float`-Werte haben.
///
## Zusammenfassung
Mit **FastAPI** haben Sie die maximale Flexibilitรคt von Pydantic-Modellen, wรคhrend Ihr Code einfach, kurz und elegant bleibt.

73
docs/de/docs/tutorial/body-updates.md

@ -6,24 +6,30 @@ Um einen Artikel zu aktualisieren, kรถnnen Sie die <a href="https://developer.mo
Sie kรถnnen den `jsonable_encoder` verwenden, um die empfangenen Daten in etwas zu konvertieren, das als JSON gespeichert werden kann (in z. B. einer NoSQL-Datenbank). Zum Beispiel, um ein `datetime` in einen `str` zu konvertieren.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="28-33"
{!> ../../../docs_src/body_updates/tutorial001_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="30-35"
{!> ../../../docs_src/body_updates/tutorial001_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="30-35"
{!> ../../../docs_src/body_updates/tutorial001.py!}
```
////
`PUT` wird verwendet, um Daten zu empfangen, die die existierenden Daten ersetzen sollen.
### Warnung bezรผglich des Ersetzens
@ -48,7 +54,8 @@ Sie kรถnnen auch die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/
Das bedeutet, sie senden nur die Daten, die Sie aktualisieren wollen, der Rest bleibt unverรคndert.
!!! note "Hinweis"
/// note | "Hinweis"
`PATCH` wird seltener verwendet und ist weniger bekannt als `PUT`.
Und viele Teams verwenden ausschlieรŸlich `PUT`, selbst fรผr nur Teil-Aktualisierungen.
@ -57,68 +64,88 @@ Das bedeutet, sie senden nur die Daten, die Sie aktualisieren wollen, der Rest b
Aber dieser Leitfaden zeigt Ihnen mehr oder weniger, wie die beiden normalerweise verwendet werden.
///
### Pydantics `exclude_unset`-Parameter verwenden
Wenn Sie Teil-Aktualisierungen entgegennehmen, ist der `exclude_unset`-Parameter in der `.model_dump()`-Methode von Pydantic-Modellen sehr nรผtzlich.
Wie in `item.model_dump(exclude_unset=True)`.
!!! info
/// info
In Pydantic v1 hieรŸ diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstรผtzt) und in `.model_dump()` umbenannt.
Die Beispiele hier verwenden `.dict()` fรผr die Kompatibilitรคt mit Pydantic v1, Sie sollten jedoch stattdessen `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden kรถnnen.
///
Das wird ein `dict` erstellen, mit nur den Daten, die gesetzt wurden als das `item`-Modell erstellt wurde, Defaultwerte ausgeschlossen.
Sie kรถnnen das verwenden, um ein `dict` zu erstellen, das nur die (im Request) gesendeten Daten enthรคlt, ohne Defaultwerte:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="32"
{!> ../../../docs_src/body_updates/tutorial002_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="34"
{!> ../../../docs_src/body_updates/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="34"
{!> ../../../docs_src/body_updates/tutorial002.py!}
```
////
### Pydantics `update`-Parameter verwenden
Jetzt kรถnnen Sie eine Kopie des existierenden Modells mittels `.model_copy()` erstellen, wobei Sie dem `update`-Parameter ein `dict` mit den zu รคndernden Daten รผbergeben.
!!! info
/// info
In Pydantic v1 hieรŸ diese Methode `.copy()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstรผtzt) und in `.model_copy()` umbenannt.
Die Beispiele hier verwenden `.copy()` fรผr die Kompatibilitรคt mit Pydantic v1, Sie sollten jedoch stattdessen `.model_copy()` verwenden, wenn Sie Pydantic v2 verwenden kรถnnen.
///
Wie in `stored_item_model.model_copy(update=update_data)`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="33"
{!> ../../../docs_src/body_updates/tutorial002_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="35"
{!> ../../../docs_src/body_updates/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="35"
{!> ../../../docs_src/body_updates/tutorial002.py!}
```
////
### Rekapitulation zum teilweisen Ersetzen
Zusammengefasst, um Teil-Ersetzungen vorzunehmen:
@ -134,32 +161,44 @@ Zusammengefasst, um Teil-Ersetzungen vorzunehmen:
* Speichern Sie die Daten in Ihrer Datenbank.
* Geben Sie das aktualisierte Modell zurรผck.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="28-35"
{!> ../../../docs_src/body_updates/tutorial002_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="30-37"
{!> ../../../docs_src/body_updates/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="30-37"
{!> ../../../docs_src/body_updates/tutorial002.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Sie kรถnnen tatsรคchlich die gleiche Technik mit einer HTTP `PUT` Operation verwenden.
Aber dieses Beispiel verwendet `PATCH`, da dieses fรผr solche Anwendungsfรคlle geschaffen wurde.
!!! note "Hinweis"
///
/// note | "Hinweis"
Beachten Sie, dass das hereinkommende Modell immer noch validiert wird.
Wenn Sie also Teil-Aktualisierungen empfangen wollen, die alle Attribute auslassen kรถnnen, mรผssen Sie ein Modell haben, dessen Attribute alle als optional gekennzeichnet sind (mit Defaultwerten oder `None`).
Um zu unterscheiden zwischen Modellen fรผr **Aktualisierungen**, mit lauter optionalen Werten, und solchen fรผr die **Erzeugung**, mit benรถtigten Werten, kรถnnen Sie die Techniken verwenden, die in [Extramodelle](extra-models.md){.internal-link target=_blank} beschrieben wurden.
///

63
docs/de/docs/tutorial/body.md

@ -8,47 +8,58 @@ Ihre API sendet fast immer einen **Response**body. Aber Clients senden nicht unb
Um einen **Request**body zu deklarieren, verwenden Sie <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>-Modelle mit allen deren Fรคhigkeiten und Vorzรผgen.
!!! info
/// info
Um Daten zu versenden, sollten Sie eines von: `POST` (meistverwendet), `PUT`, `DELETE` oder `PATCH` verwenden.
Senden Sie einen Body mit einem `GET`-Request, dann fรผhrt das laut Spezifikation zu undefiniertem Verhalten. Trotzdem wird es von FastAPI unterstรผtzt, fรผr sehr komplexe/extreme Anwendungsfรคlle.
Da aber davon abgeraten wird, zeigt die interaktive Dokumentation mit Swagger-Benutzeroberflรคche die Dokumentation fรผr den Body auch nicht an, wenn `GET` verwendet wird. Dazwischengeschaltete Proxys unterstรผtzen es mรถglicherweise auch nicht.
///
## Importieren Sie Pydantics `BaseModel`
Zuerst mรผssen Sie `BaseModel` von `pydantic` importieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="2"
{!> ../../../docs_src/body/tutorial001_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4"
{!> ../../../docs_src/body/tutorial001.py!}
```
////
## Erstellen Sie Ihr Datenmodell
Dann deklarieren Sie Ihr Datenmodell als eine Klasse, die von `BaseModel` erbt.
Verwenden Sie Standard-Python-Typen fรผr die Klassenattribute:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="5-9"
{!> ../../../docs_src/body/tutorial001_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="7-11"
{!> ../../../docs_src/body/tutorial001.py!}
```
////
Wie auch bei Query-Parametern gilt, wenn ein Modellattribut einen Defaultwert hat, ist das Attribut nicht erforderlich. Ansonsten ist es erforderlich. Verwenden Sie `None`, um es als optional zu kennzeichnen.
Zum Beispiel deklariert das obige Modell ein JSON "`object`" (oder Python-`dict`) wie dieses:
@ -75,18 +86,22 @@ Da `description` und `tax` optional sind (mit `None` als Defaultwert), wรคre fol
Um es zu Ihrer *Pfadoperation* hinzuzufรผgen, deklarieren Sie es auf die gleiche Weise, wie Sie Pfad- und Query-Parameter deklariert haben:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="16"
{!> ../../../docs_src/body/tutorial001_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="18"
{!> ../../../docs_src/body/tutorial001.py!}
```
////
... und deklarieren Sie seinen Typ als das Modell, welches Sie erstellt haben, `Item`.
## Resultate
@ -134,7 +149,8 @@ Aber Sie bekommen die gleiche Editor-Unterstรผtzung in <a href="https://www.jetb
<img src="/img/tutorial/body/image05.png">
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> als Ihren Editor verwenden, probieren Sie das <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a> aus.
Es verbessert die Editor-Unterstรผtzung fรผr Pydantic-Modelle, mit:
@ -145,69 +161,86 @@ Aber Sie bekommen die gleiche Editor-Unterstรผtzung in <a href="https://www.jetb
* Suchen
* Inspektionen
///
## Das Modell verwenden
Innerhalb der Funktion kรถnnen Sie alle Attribute des Modells direkt verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19"
{!> ../../../docs_src/body/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="21"
{!> ../../../docs_src/body/tutorial002.py!}
```
////
## Requestbody- + Pfad-Parameter
Sie kรถnnen Pfad- und Requestbody-Parameter gleichzeitig deklarieren.
**FastAPI** erkennt, dass Funktionsparameter, die mit Pfad-Parametern รผbereinstimmen, **vom Pfad genommen** werden sollen, und dass Funktionsparameter, welche Pydantic-Modelle sind, **vom Requestbody genommen** werden sollen.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="15-16"
{!> ../../../docs_src/body/tutorial003_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17-18"
{!> ../../../docs_src/body/tutorial003.py!}
```
////
## Requestbody- + Pfad- + Query-Parameter
Sie kรถnnen auch zur gleichen Zeit **Body-**, **Pfad-** und **Query-Parameter** deklarieren.
**FastAPI** wird jeden Parameter korrekt erkennen und die Daten vom richtigen Ort holen.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="16"
{!> ../../../docs_src/body/tutorial004_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="18"
{!> ../../../docs_src/body/tutorial004.py!}
```
////
Die Funktionsparameter werden wie folgt erkannt:
* Wenn der Parameter auch im **Pfad** deklariert wurde, wird er als Pfad-Parameter interpretiert.
* Wenn der Parameter ein **einfacher Typ** ist (wie `int`, `float`, `str`, `bool`, usw.), wird er als **Query**-Parameter interpretiert.
* Wenn der Parameter vom Typ eines **Pydantic-Modells** ist, wird er als Request**body** interpretiert.
!!! note "Hinweis"
/// note | "Hinweis"
FastAPI weiรŸ, dass der Wert von `q` nicht erforderlich ist, wegen des definierten Defaultwertes `= None`
Das `Union` in `Union[str, None]` wird von FastAPI nicht verwendet, aber es erlaubt Ihrem Editor, Sie besser zu unterstรผtzen und Fehler zu erkennen.
///
## Ohne Pydantic
Wenn Sie keine Pydantic-Modelle verwenden wollen, kรถnnen Sie auch **Body**-Parameter nehmen. Siehe die Dokumentation unter [Body โ€“ Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#einzelne-werte-im-body){.internal-link target=\_blank}.

70
docs/de/docs/tutorial/cookie-params.md

@ -6,92 +6,130 @@ So wie `Query`- und `Path`-Parameter kรถnnen Sie auch <abbr title='Cookie โ€“
Importieren Sie zuerst `Cookie`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="3"
{!> ../../../docs_src/cookie_params/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="3"
{!> ../../../docs_src/cookie_params/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="3"
{!> ../../../docs_src/cookie_params/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/cookie_params/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3"
{!> ../../../docs_src/cookie_params/tutorial001.py!}
```
////
## `Cookie`-Parameter deklarieren
Dann deklarieren Sie Ihre Cookie-Parameter, auf die gleiche Weise, wie Sie auch `Path`- und `Query`-Parameter deklarieren.
Der erste Wert ist der Typ. Sie kรถnnen `Cookie` die gehabten Extra Validierungs- und Beschreibungsparameter hinzufรผgen. Danach kรถnnen Sie einen Defaultwert vergeben:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9"
{!> ../../../docs_src/cookie_params/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/cookie_params/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10"
{!> ../../../docs_src/cookie_params/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/cookie_params/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9"
{!> ../../../docs_src/cookie_params/tutorial001.py!}
```
!!! note "Technische Details"
////
/// note | "Technische Details"
`Cookie` ist eine Schwesterklasse von `Path` und `Query`. Sie erbt von derselben gemeinsamen `Param`-Elternklasse.
Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`, `Cookie` und andere von `fastapi` importieren, diese tatsรคchlich Funktionen sind, welche spezielle Klassen zurรผckgeben.
!!! info
///
/// info
Um Cookies zu deklarieren, mรผssen Sie `Cookie` verwenden, da diese Parameter sonst als Query-Parameter interpretiert werden wรผrden.
///
## Zusammenfassung
Deklarieren Sie Cookies mittels `Cookie`, auf die gleiche Weise wie bei `Query` und `Path`.

293
docs/de/docs/tutorial/dependencies/classes-as-dependencies.md

@ -6,42 +6,58 @@ Bevor wir tiefer in das **Dependency Injection** System eintauchen, lassen Sie u
Im vorherigen Beispiel haben wir ein `dict` von unserer Abhรคngigkeit (โ€žDependableโ€œ) zurรผckgegeben:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9"
{!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="11"
{!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12"
{!> ../../../docs_src/dependencies/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/dependencies/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11"
{!> ../../../docs_src/dependencies/tutorial001.py!}
```
////
Aber dann haben wir ein `dict` im Parameter `commons` der *Pfadoperation-Funktion*.
Und wir wissen, dass Editoren nicht viel Unterstรผtzung (wie etwa Code-Vervollstรคndigung) fรผr `dict`s bieten kรถnnen, weil sie ihre Schlรผssel- und Werttypen nicht kennen.
@ -103,118 +119,166 @@ Das gilt auch fรผr Callables ohne Parameter. So wie es auch fรผr *Pfadoperation-
Dann kรถnnen wir das โ€žDependableโ€œ `common_parameters` der Abhรคngigkeit von oben in die Klasse `CommonQueryParams` รคndern:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="11-15"
{!> ../../../docs_src/dependencies/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="11-15"
{!> ../../../docs_src/dependencies/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12-16"
{!> ../../../docs_src/dependencies/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9-13"
{!> ../../../docs_src/dependencies/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11-15"
{!> ../../../docs_src/dependencies/tutorial002.py!}
```
////
Achten Sie auf die Methode `__init__`, die zum Erstellen der Instanz der Klasse verwendet wird:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="12"
{!> ../../../docs_src/dependencies/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="12"
{!> ../../../docs_src/dependencies/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="13"
{!> ../../../docs_src/dependencies/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10"
{!> ../../../docs_src/dependencies/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="12"
{!> ../../../docs_src/dependencies/tutorial002.py!}
```
////
... sie hat die gleichen Parameter wie unsere vorherige `common_parameters`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="8"
{!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10"
{!> ../../../docs_src/dependencies/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6"
{!> ../../../docs_src/dependencies/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9"
{!> ../../../docs_src/dependencies/tutorial001.py!}
```
////
Diese Parameter werden von **FastAPI** verwendet, um die Abhรคngigkeit โ€žaufzulรถsenโ€œ.
In beiden Fรคllen wird sie haben:
@ -229,63 +293,86 @@ In beiden Fรคllen werden die Daten konvertiert, validiert, im OpenAPI-Schema dok
Jetzt kรถnnen Sie Ihre Abhรคngigkeit mithilfe dieser Klasse deklarieren.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20"
{!> ../../../docs_src/dependencies/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17"
{!> ../../../docs_src/dependencies/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial002.py!}
```
////
**FastAPI** ruft die Klasse `CommonQueryParams` auf. Dadurch wird eine โ€žInstanzโ€œ dieser Klasse erstellt und die Instanz wird als Parameter `commons` an Ihre Funktion รผberreicht.
## Typannotation vs. `Depends`
Beachten Sie, wie wir `CommonQueryParams` im obigen Code zweimal schreiben:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python
commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
commons: CommonQueryParams = Depends(CommonQueryParams)
```
////
Das letzte `CommonQueryParams`, in:
```Python
@ -300,78 +387,108 @@ Aus diesem extrahiert FastAPI die deklarierten Parameter, und dieses ist es, was
In diesem Fall hat das erste `CommonQueryParams` in:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python
commons: Annotated[CommonQueryParams, ...
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
commons: CommonQueryParams ...
```
////
... keine besondere Bedeutung fรผr **FastAPI**. FastAPI verwendet es nicht fรผr die Datenkonvertierung, -validierung, usw. (da es dafรผr `Depends(CommonQueryParams)` verwendet).
Sie kรถnnten tatsรคchlich einfach schreiben:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python
commons: Annotated[Any, Depends(CommonQueryParams)]
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
commons = Depends(CommonQueryParams)
```
////
... wie in:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20"
{!> ../../../docs_src/dependencies/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17"
{!> ../../../docs_src/dependencies/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial003.py!}
```
////
Es wird jedoch empfohlen, den Typ zu deklarieren, da Ihr Editor so weiรŸ, was als Parameter `commons` รผbergeben wird, und Ihnen dann bei der Codevervollstรคndigung, Typprรผfungen, usw. helfen kann:
<img src="/img/tutorial/dependencies/image02.png">
@ -380,102 +497,142 @@ Es wird jedoch empfohlen, den Typ zu deklarieren, da Ihr Editor so weiรŸ, was al
Aber Sie sehen, dass wir hier etwas Codeduplizierung haben, indem wir `CommonQueryParams` zweimal schreiben:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python
commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
commons: CommonQueryParams = Depends(CommonQueryParams)
```
////
**FastAPI** bietet eine Abkรผrzung fรผr diese Fรคlle, wo die Abhรคngigkeit *speziell* eine Klasse ist, welche **FastAPI** aufruft, um eine Instanz der Klasse selbst zu erstellen.
In diesem speziellen Fall kรถnnen Sie Folgendes tun:
Anstatt zu schreiben:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python
commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
commons: CommonQueryParams = Depends(CommonQueryParams)
```
////
... schreiben Sie:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python
commons: Annotated[CommonQueryParams, Depends()]
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
commons: CommonQueryParams = Depends()
```
////
Sie deklarieren die Abhรคngigkeit als Typ des Parameters und verwenden `Depends()` ohne Parameter, anstatt die vollstรคndige Klasse *erneut* in `Depends(CommonQueryParams)` schreiben zu mรผssen.
Dasselbe Beispiel wรผrde dann so aussehen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20"
{!> ../../../docs_src/dependencies/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17"
{!> ../../../docs_src/dependencies/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial004.py!}
```
////
... und **FastAPI** wird wissen, was zu tun ist.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie das eher verwirrt, als Ihnen zu helfen, ignorieren Sie es, Sie *brauchen* es nicht.
Es ist nur eine Abkรผrzung. Es geht **FastAPI** darum, Ihnen dabei zu helfen, Codeverdoppelung zu minimieren.
///

78
docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md

@ -14,41 +14,56 @@ Der *Pfadoperation-Dekorator* erhรคlt ein optionales Argument `dependencies`.
Es sollte eine `list`e von `Depends()` sein:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="18"
{!> ../../../docs_src/dependencies/tutorial006_an.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17"
{!> ../../../docs_src/dependencies/tutorial006.py!}
```
////
Diese Abhรคngigkeiten werden auf die gleiche Weise wie normale Abhรคngigkeiten ausgefรผhrt/aufgelรถst. Aber ihr Wert (falls sie einen zurรผckgeben) wird nicht an Ihre *Pfadoperation-Funktion* รผbergeben.
!!! tip "Tipp"
/// tip | "Tipp"
Einige Editoren prรผfen, ob Funktionsparameter nicht verwendet werden, und zeigen das als Fehler an.
Wenn Sie `dependencies` im *Pfadoperation-Dekorator* verwenden, stellen Sie sicher, dass sie ausgefรผhrt werden, wรคhrend gleichzeitig Ihr Editor/Ihre Tools keine Fehlermeldungen ausgeben.
Damit wird auch vermieden, neue Entwickler mรถglicherweise zu verwirren, die einen nicht verwendeten Parameter in Ihrem Code sehen und ihn fรผr unnรถtig halten kรถnnten.
!!! info
///
/// info
In diesem Beispiel verwenden wir zwei erfundene benutzerdefinierte Header `X-Key` und `X-Token`.
Aber in realen Fรคllen wรผrden Sie bei der Implementierung von Sicherheit mehr Vorteile durch die Verwendung der integrierten [Sicherheits-Werkzeuge (siehe nรคchstes Kapitel)](../security/index.md){.internal-link target=_blank} erzielen.
///
## Abhรคngigkeitsfehler und -Rรผckgabewerte
Sie kรถnnen dieselben Abhรคngigkeits-*Funktionen* verwenden, die Sie normalerweise verwenden.
@ -57,79 +72,106 @@ Sie kรถnnen dieselben Abhรคngigkeits-*Funktionen* verwenden, die Sie normalerwei
Sie kรถnnen Anforderungen fรผr einen Request (wie Header) oder andere Unterabhรคngigkeiten deklarieren:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="8 13"
{!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="7 12"
{!> ../../../docs_src/dependencies/tutorial006_an.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6 11"
{!> ../../../docs_src/dependencies/tutorial006.py!}
```
////
### Exceptions auslรถsen
Die Abhรคngigkeiten kรถnnen Exceptions `raise`n, genau wie normale Abhรคngigkeiten:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10 15"
{!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9 14"
{!> ../../../docs_src/dependencies/tutorial006_an.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8 13"
{!> ../../../docs_src/dependencies/tutorial006.py!}
```
////
### Rรผckgabewerte
Und sie kรถnnen Werte zurรผckgeben oder nicht, die Werte werden nicht verwendet.
Sie kรถnnen also eine normale Abhรคngigkeit (die einen Wert zurรผckgibt), die Sie bereits an anderer Stelle verwenden, wiederverwenden, und auch wenn der Wert nicht verwendet wird, wird die Abhรคngigkeit ausgefรผhrt:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="11 16"
{!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10 15"
{!> ../../../docs_src/dependencies/tutorial006_an.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9 14"
{!> ../../../docs_src/dependencies/tutorial006.py!}
```
////
## Abhรคngigkeiten fรผr eine Gruppe von *Pfadoperationen*
Wenn Sie spรคter lesen, wie Sie grรถรŸere Anwendungen strukturieren ([GrรถรŸere Anwendungen โ€“ Mehrere Dateien](../../tutorial/bigger-applications.md){.internal-link target=_blank}), mรถglicherweise mit mehreren Dateien, lernen Sie, wie Sie einen einzelnen `dependencies`-Parameter fรผr eine Gruppe von *Pfadoperationen* deklarieren.

104
docs/de/docs/tutorial/dependencies/dependencies-with-yield.md

@ -4,10 +4,14 @@ FastAPI unterstรผtzt Abhรคngigkeiten, die nach Abschluss einige <abbr title="Man
Verwenden Sie dazu `yield` statt `return` und schreiben Sie die zusรคtzlichen Schritte / den zusรคtzlichen Code danach.
!!! tip "Tipp"
/// tip | "Tipp"
Stellen Sie sicher, dass Sie `yield` nur einmal pro Abhรคngigkeit verwenden.
!!! note "Technische Details"
///
/// note | "Technische Details"
Jede Funktion, die dekoriert werden kann mit:
* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> oder
@ -17,6 +21,8 @@ Verwenden Sie dazu `yield` statt `return` und schreiben Sie die zusรคtzlichen Sc
Tatsรคchlich verwendet FastAPI diese beiden Dekoratoren intern.
///
## Eine Datenbank-Abhรคngigkeit mit `yield`.
Sie kรถnnten damit beispielsweise eine Datenbanksession erstellen und diese nach Abschluss schlieรŸen.
@ -39,11 +45,14 @@ Der auf die `yield`-Anweisung folgende Code wird ausgefรผhrt, nachdem die Respon
{!../../../docs_src/dependencies/tutorial007.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen `async`hrone oder regulรคre Funktionen verwenden.
**FastAPI** wird bei jeder das Richtige tun, so wie auch bei normalen Abhรคngigkeiten.
///
## Eine Abhรคngigkeit mit `yield` und `try`.
Wenn Sie einen `try`-Block in einer Abhรคngigkeit mit `yield` verwenden, empfangen Sie alle Exceptions, die bei Verwendung der Abhรคngigkeit geworfen wurden.
@ -66,54 +75,72 @@ Sie kรถnnen Unterabhรคngigkeiten und โ€žBรคumeโ€œ von Unterabhรคngigkeiten belie
Beispielsweise kann `dependency_c` von `dependency_b` und `dependency_b` von `dependency_a` abhรคngen:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="6 14 22"
{!> ../../../docs_src/dependencies/tutorial008_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="5 13 21"
{!> ../../../docs_src/dependencies/tutorial008_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="4 12 20"
{!> ../../../docs_src/dependencies/tutorial008.py!}
```
////
Und alle kรถnnen `yield` verwenden.
In diesem Fall benรถtigt `dependency_c` zum Ausfรผhren seines Exit-Codes, dass der Wert von `dependency_b` (hier `dep_b` genannt) verfรผgbar ist.
Und wiederum benรถtigt `dependency_b` den Wert von `dependency_a` (hier `dep_a` genannt) fรผr seinen Exit-Code.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="18-19 26-27"
{!> ../../../docs_src/dependencies/tutorial008_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17-18 25-26"
{!> ../../../docs_src/dependencies/tutorial008_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="16-17 24-25"
{!> ../../../docs_src/dependencies/tutorial008.py!}
```
////
Auf die gleiche Weise kรถnnten Sie einige Abhรคngigkeiten mit `yield` und einige andere Abhรคngigkeiten mit `return` haben, und alle kรถnnen beliebig voneinander abhรคngen.
Und Sie kรถnnten eine einzelne Abhรคngigkeit haben, die auf mehreren ge`yield`eten Abhรคngigkeiten basiert, usw.
@ -122,44 +149,58 @@ Sie kรถnnen beliebige Kombinationen von Abhรคngigkeiten haben.
**FastAPI** stellt sicher, dass alles in der richtigen Reihenfolge ausgefรผhrt wird.
!!! note "Technische Details"
/// note | "Technische Details"
Dieses funktioniert dank Pythons <a href="https://docs.python.org/3/library/contextlib.html" class="external-link" target="_blank">Kontextmanager</a>.
**FastAPI** verwendet sie intern, um das zu erreichen.
///
## Abhรคngigkeiten mit `yield` und `HTTPException`.
Sie haben gesehen, dass Ihre Abhรคngigkeiten `yield` verwenden kรถnnen und `try`-Blรถcke haben kรถnnen, die Exceptions abfangen.
Auf die gleiche Weise kรถnnten Sie im Exit-Code nach dem `yield` eine `HTTPException` oder รคhnliches auslรถsen.
!!! tip "Tipp"
/// tip | "Tipp"
Dies ist eine etwas fortgeschrittene Technik, die Sie in den meisten Fรคllen nicht wirklich benรถtigen, da Sie Exceptions (einschlieรŸlich `HTTPException`) innerhalb des restlichen Anwendungscodes auslรถsen kรถnnen, beispielsweise in der *Pfadoperation-Funktion*.
Aber es ist fรผr Sie da, wenn Sie es brauchen. ๐Ÿค“
=== "Python 3.9+"
///
//// tab | Python 3.9+
```Python hl_lines="18-22 31"
{!> ../../../docs_src/dependencies/tutorial008b_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17-21 30"
{!> ../../../docs_src/dependencies/tutorial008b_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="16-20 29"
{!> ../../../docs_src/dependencies/tutorial008b.py!}
```
////
Eine Alternative zum Abfangen von Exceptions (und mรถglicherweise auch zum Auslรถsen einer weiteren `HTTPException`) besteht darin, einen [benutzerdefinierten Exceptionhandler](../handling-errors.md#benutzerdefinierte-exceptionhandler-definieren){.internal-link target=_blank} zu erstellen.
## Ausfรผhrung von Abhรคngigkeiten mit `yield`
@ -201,35 +242,46 @@ participant tasks as Hintergrundtasks
end
```
!!! info
/// info
Es wird nur **eine Response** an den Client gesendet. Es kann eine Error-Response oder die Response der *Pfadoperation* sein.
Nachdem eine dieser Responses gesendet wurde, kann keine weitere Response gesendet werden.
!!! tip "Tipp"
///
/// tip | "Tipp"
Obiges Diagramm verwendet `HTTPException`, aber Sie kรถnnen auch jede andere Exception auslรถsen, die Sie in einer Abhรคngigkeit mit `yield` abfangen, oder mit einem [benutzerdefinierten Exceptionhandler](../handling-errors.md#benutzerdefinierte-exceptionhandler-definieren){.internal-link target=_blank} erstellt haben.
Wenn Sie eine Exception auslรถsen, wird diese mit yield an die Abhรคngigkeiten รผbergeben, einschlieรŸlich `HTTPException`, und dann **erneut** an die Exceptionhandler. Wenn es fรผr diese Exception keinen Exceptionhandler gibt, wird sie von der internen Default-`ServerErrorMiddleware` gehandhabt, was einen HTTP-Statuscode 500 zurรผckgibt, um den Client darรผber zu informieren, dass ein Fehler auf dem Server aufgetreten ist.
///
## Abhรคngigkeiten mit `yield`, `HTTPException` und Hintergrundtasks
!!! warning "Achtung"
/// warning | "Achtung"
Sie benรถtigen diese technischen Details hรถchstwahrscheinlich nicht, Sie kรถnnen diesen Abschnitt รผberspringen und weiter unten fortfahren.
Diese Details sind vor allem dann nรผtzlich, wenn Sie eine Version von FastAPI vor 0.106.0 verwendet haben und Ressourcen aus Abhรคngigkeiten mit `yield` in Hintergrundtasks verwendet haben.
///
Vor FastAPI 0.106.0 war das Auslรถsen von Exceptions nach `yield` nicht mรถglich, der Exit-Code in Abhรคngigkeiten mit `yield` wurde ausgefรผhrt, *nachdem* die Response gesendet wurde, die [Exceptionhandler](../handling-errors.md#benutzerdefinierte-exceptionhandler-definieren){.internal-link target=_blank} wรคren also bereits ausgefรผhrt worden.
Dies wurde hauptsรคchlich so konzipiert, damit die gleichen Objekte, die durch Abhรคngigkeiten ge`yield`et werden, innerhalb von Hintergrundtasks verwendet werden kรถnnen, da der Exit-Code ausgefรผhrt wird, nachdem die Hintergrundtasks abgeschlossen sind.
Da dies jedoch bedeuten wรผrde, darauf zu warten, dass die Response durch das Netzwerk reist, wรคhrend eine Ressource unnรถtigerweise in einer Abhรคngigkeit mit yield gehalten wird (z. B. eine Datenbankverbindung), wurde dies in FastAPI 0.106.0 geรคndert.
!!! tip "Tipp"
/// tip | "Tipp"
Darรผber hinaus handelt es sich bei einem Hintergrundtask normalerweise um einen unabhรคngigen Satz von Logik, der separat behandelt werden sollte, mit eigenen Ressourcen (z. B. einer eigenen Datenbankverbindung).
Auf diese Weise erhalten Sie wahrscheinlich saubereren Code.
///
Wenn Sie sich frรผher auf dieses Verhalten verlassen haben, sollten Sie jetzt die Ressourcen fรผr Hintergrundtasks innerhalb des Hintergrundtasks selbst erstellen und intern nur Daten verwenden, die nicht von den Ressourcen von Abhรคngigkeiten mit `yield` abhรคngen.
Anstatt beispielsweise dieselbe Datenbanksitzung zu verwenden, wรผrden Sie eine neue Datenbanksitzung innerhalb des Hintergrundtasks erstellen und die Objekte mithilfe dieser neuen Sitzung aus der Datenbank abrufen. Und anstatt das Objekt aus der Datenbank als Parameter an die Hintergrundtask-Funktion zu รผbergeben, wรผrden Sie die ID dieses Objekts รผbergeben und das Objekt dann innerhalb der Hintergrundtask-Funktion erneut laden.
@ -256,11 +308,14 @@ Wenn Sie eine Abhรคngigkeit mit `yield` erstellen, erstellt **FastAPI** dafรผr i
### Kontextmanager in Abhรคngigkeiten mit `yield` verwenden
!!! warning "Achtung"
/// warning | "Achtung"
Dies ist mehr oder weniger eine โ€žfortgeschritteneโ€œ Idee.
Wenn Sie gerade erst mit **FastAPI** beginnen, mรถchten Sie das vielleicht vorerst รผberspringen.
///
In Python kรถnnen Sie Kontextmanager erstellen, indem Sie <a href="https://docs.python.org/3/reference/datamodel.html#context-managers" class="external-link" target="_blank">eine Klasse mit zwei Methoden erzeugen: `__enter__()` und `__exit__()`</a>.
Sie kรถnnen solche auch innerhalb von **FastAPI**-Abhรคngigkeiten mit `yield` verwenden, indem Sie `with`- oder `async with`-Anweisungen innerhalb der Abhรคngigkeits-Funktion verwenden:
@ -269,7 +324,8 @@ Sie kรถnnen solche auch innerhalb von **FastAPI**-Abhรคngigkeiten mit `yield` ve
{!../../../docs_src/dependencies/tutorial010.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Andere Mรถglichkeiten, einen Kontextmanager zu erstellen, sind:
* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> oder
@ -282,3 +338,5 @@ Sie kรถnnen solche auch innerhalb von **FastAPI**-Abhรคngigkeiten mit `yield` ve
Aber Sie mรผssen die Dekoratoren nicht fรผr FastAPI-Abhรคngigkeiten verwenden (und das sollten Sie auch nicht).
FastAPI erledigt das intern fรผr Sie.
///

17
docs/de/docs/tutorial/dependencies/global-dependencies.md

@ -6,27 +6,36 @@ Bei einigen Anwendungstypen mรถchten Sie mรถglicherweise Abhรคngigkeiten zur ges
In diesem Fall werden sie auf alle *Pfadoperationen* in der Anwendung angewendet:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="16"
{!> ../../../docs_src/dependencies/tutorial012_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="16"
{!> ../../../docs_src/dependencies/tutorial012_an.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="15"
{!> ../../../docs_src/dependencies/tutorial012.py!}
```
////
Und alle Ideen aus dem Abschnitt รผber das [Hinzufรผgen von `dependencies` zu den *Pfadoperation-Dekoratoren*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} gelten weiterhin, aber in diesem Fall fรผr alle *Pfadoperationen* in der Anwendung.
## Abhรคngigkeiten fรผr Gruppen von *Pfadoperationen*

127
docs/de/docs/tutorial/dependencies/index.md

@ -30,42 +30,58 @@ Aber so kรถnnen wir uns besser auf die Funktionsweise des **Dependency Injection
Konzentrieren wir uns zunรคchst auf die Abhรคngigkeit - die Dependency.
Es handelt sich einfach um eine Funktion, die die gleichen Parameter entgegennimmt wie eine *Pfadoperation-Funktion*:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="8-9"
{!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="8-11"
{!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9-12"
{!> ../../../docs_src/dependencies/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6-7"
{!> ../../../docs_src/dependencies/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8-11"
{!> ../../../docs_src/dependencies/tutorial001.py!}
```
////
Das war's schon.
**Zwei Zeilen**.
@ -84,91 +100,126 @@ In diesem Fall erwartet diese Abhรคngigkeit:
Und dann wird einfach ein `dict` zurรผckgegeben, welches diese Werte enthรคlt.
!!! info
/// info
FastAPI unterstรผtzt (und empfiehlt die Verwendung von) `Annotated` seit Version 0.95.0.
Wenn Sie eine รคltere Version haben, werden Sie Fehler angezeigt bekommen, wenn Sie versuchen, `Annotated` zu verwenden.
Bitte [aktualisieren Sie FastAPI](../../deployment/versions.md#upgrade-der-fastapi-versionen){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden.
///
### `Depends` importieren
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="3"
{!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="3"
{!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="3"
{!> ../../../docs_src/dependencies/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/dependencies/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3"
{!> ../../../docs_src/dependencies/tutorial001.py!}
```
////
### Deklarieren der Abhรคngigkeit im <abbr title="Das Abhรคngige, der Verwender der Abhรคngigkeit">โ€žDependantโ€œ</abbr>
So wie auch `Body`, `Query`, usw., verwenden Sie `Depends` mit den Parametern Ihrer *Pfadoperation-Funktion*:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="13 18"
{!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="15 20"
{!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="16 21"
{!> ../../../docs_src/dependencies/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11 16"
{!> ../../../docs_src/dependencies/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="15 20"
{!> ../../../docs_src/dependencies/tutorial001.py!}
```
////
Obwohl Sie `Depends` in den Parametern Ihrer Funktion genauso verwenden wie `Body`, `Query`, usw., funktioniert `Depends` etwas anders.
Sie รผbergeben `Depends` nur einen einzigen Parameter.
@ -179,9 +230,12 @@ Sie **rufen diese nicht direkt auf** (fรผgen Sie am Ende keine Klammern hinzu),
Und diese Funktion akzeptiert Parameter auf die gleiche Weise wie *Pfadoperation-Funktionen*.
!!! tip "Tipp"
/// tip | "Tipp"
Im nรคchsten Kapitel erfahren Sie, welche anderen โ€žDingeโ€œ, auรŸer Funktionen, Sie als Abhรคngigkeiten verwenden kรถnnen.
///
Immer wenn ein neuer Request eintrifft, kรผmmert sich **FastAPI** darum:
* Ihre Abhรคngigkeitsfunktion (โ€žDependableโ€œ) mit den richtigen Parametern aufzurufen.
@ -201,11 +255,14 @@ common_parameters --> read_users
Auf diese Weise schreiben Sie gemeinsam genutzten Code nur einmal, und **FastAPI** kรผmmert sich darum, ihn fรผr Ihre *Pfadoperationen* aufzurufen.
!!! check
/// check
Beachten Sie, dass Sie keine spezielle Klasse erstellen und diese irgendwo an **FastAPI** รผbergeben mรผssen, um sie zu โ€žregistrierenโ€œ oder so รคhnlich.
Sie รผbergeben es einfach an `Depends` und **FastAPI** weiรŸ, wie der Rest erledigt wird.
///
## `Annotated`-Abhรคngigkeiten wiederverwenden
In den Beispielen oben sehen Sie, dass es ein kleines bisschen **Codeverdoppelung** gibt.
@ -218,29 +275,38 @@ commons: Annotated[dict, Depends(common_parameters)]
Da wir jedoch `Annotated` verwenden, kรถnnen wir diesen `Annotated`-Wert in einer Variablen speichern und an mehreren Stellen verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="12 16 21"
{!> ../../../docs_src/dependencies/tutorial001_02_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="14 18 23"
{!> ../../../docs_src/dependencies/tutorial001_02_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="15 19 24"
{!> ../../../docs_src/dependencies/tutorial001_02_an.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Das ist schlicht Standard-Python, es wird als โ€žTypaliasโ€œ bezeichnet und ist eigentlich nicht **FastAPI**-spezifisch.
Da **FastAPI** jedoch auf Standard-Python, einschlieรŸlich `Annotated`, basiert, kรถnnen Sie diesen Trick in Ihrem Code verwenden. ๐Ÿ˜Ž
///
Die Abhรคngigkeiten funktionieren weiterhin wie erwartet, und das **Beste daran** ist, dass die **Typinformationen erhalten bleiben**, was bedeutet, dass Ihr Editor Ihnen weiterhin **automatische Vervollstรคndigung**, **Inline-Fehler**, usw. bieten kann. Das Gleiche gilt fรผr andere Tools wie `mypy`.
Das ist besonders nรผtzlich, wenn Sie es in einer **groรŸen Codebasis** verwenden, in der Sie in **vielen *Pfadoperationen*** immer wieder **dieselben Abhรคngigkeiten** verwenden.
@ -255,9 +321,12 @@ Und Sie kรถnnen Abhรคngigkeiten mit `async def` innerhalb normaler `def`-*Pfadop
Es spielt keine Rolle. **FastAPI** weiรŸ, was zu tun ist.
!!! note "Hinweis"
/// note | "Hinweis"
Wenn Ihnen das nichts sagt, lesen Sie den [Async: *โ€žIn Eile?โ€œ*](../../async.md#in-eile){.internal-link target=_blank}-Abschnitt รผber `async` und `await` in der Dokumentation.
///
## Integriert in OpenAPI
Alle Requestdeklarationen, -validierungen und -anforderungen Ihrer Abhรคngigkeiten (und Unterabhรคngigkeiten) werden in dasselbe OpenAPI-Schema integriert.

113
docs/de/docs/tutorial/dependencies/sub-dependencies.md

@ -10,42 +10,58 @@ Diese kรถnnen so **tief** verschachtelt sein, wie nรถtig.
Sie kรถnnten eine erste Abhรคngigkeit (โ€žDependableโ€œ) wie folgt erstellen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="8-9"
{!> ../../../docs_src/dependencies/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="8-9"
{!> ../../../docs_src/dependencies/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9-10"
{!> ../../../docs_src/dependencies/tutorial005_an.py!}
```
=== "Python 3.10 nicht annotiert"
////
//// tab | Python 3.10 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6-7"
{!> ../../../docs_src/dependencies/tutorial005_py310.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8-9"
{!> ../../../docs_src/dependencies/tutorial005.py!}
```
////
Diese deklariert einen optionalen Abfrageparameter `q` vom Typ `str` und gibt ihn dann einfach zurรผck.
Das ist recht einfach (nicht sehr nรผtzlich), hilft uns aber dabei, uns auf die Funktionsweise der Unterabhรคngigkeiten zu konzentrieren.
@ -54,42 +70,58 @@ Das ist recht einfach (nicht sehr nรผtzlich), hilft uns aber dabei, uns auf die
Dann kรถnnen Sie eine weitere Abhรคngigkeitsfunktion (ein โ€žDependableโ€œ) erstellen, die gleichzeitig eine eigene Abhรคngigkeit deklariert (also auch ein โ€žDependantโ€œ ist):
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="13"
{!> ../../../docs_src/dependencies/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="13"
{!> ../../../docs_src/dependencies/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="14"
{!> ../../../docs_src/dependencies/tutorial005_an.py!}
```
=== "Python 3.10 nicht annotiert"
////
//// tab | Python 3.10 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11"
{!> ../../../docs_src/dependencies/tutorial005_py310.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="13"
{!> ../../../docs_src/dependencies/tutorial005.py!}
```
////
Betrachten wir die deklarierten Parameter:
* Obwohl diese Funktion selbst eine Abhรคngigkeit ist (โ€žDependableโ€œ, etwas hรคngt von ihr ab), deklariert sie auch eine andere Abhรคngigkeit (โ€žDependantโ€œ, sie hรคngt von etwas anderem ab).
@ -101,47 +133,66 @@ Betrachten wir die deklarierten Parameter:
Diese Abhรคngigkeit verwenden wir nun wie folgt:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="23"
{!> ../../../docs_src/dependencies/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="23"
{!> ../../../docs_src/dependencies/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="24"
{!> ../../../docs_src/dependencies/tutorial005_an.py!}
```
=== "Python 3.10 nicht annotiert"
////
//// tab | Python 3.10 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19"
{!> ../../../docs_src/dependencies/tutorial005_py310.py!}
```
=== "Python 3.8 nicht annotiert"
////
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="22"
{!> ../../../docs_src/dependencies/tutorial005.py!}
```
!!! info
////
/// info
Beachten Sie, dass wir in der *Pfadoperation-Funktion* nur eine einzige Abhรคngigkeit deklarieren, den `query_or_cookie_extractor`.
Aber **FastAPI** wird wissen, dass es zuerst `query_extractor` auflรถsen muss, um dessen Resultat `query_or_cookie_extractor` zu รผbergeben, wenn dieses aufgerufen wird.
///
```mermaid
graph TB
@ -161,23 +212,30 @@ Und es speichert den zurรผckgegebenen Wert in einem <abbr title="Mechanismus, de
In einem fortgeschrittenen Szenario, bei dem Sie wissen, dass die Abhรคngigkeit bei jedem Schritt (mรถglicherweise mehrmals) in derselben Anfrage aufgerufen werden muss, anstatt den zwischengespeicherten Wert zu verwenden, kรถnnen Sie den Parameter `use_cache=False` festlegen, wenn Sie `Depends` verwenden:
=== "Python 3.8+"
//// tab | Python 3.8+
```Python hl_lines="1"
async def needy_dependency(fresh_value: Annotated[str, Depends(get_value, use_cache=False)]):
return {"fresh_value": fresh_value}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False)):
return {"fresh_value": fresh_value}
```
////
## Zusammenfassung
Abgesehen von all den ausgefallenen Wรถrtern, die hier verwendet werden, ist das **Dependency Injection**-System recht simpel.
@ -186,9 +244,12 @@ Einfach Funktionen, die genauso aussehen wie *Pfadoperation-Funktionen*.
Dennoch ist es sehr mรคchtig und ermรถglicht Ihnen die Deklaration beliebig tief verschachtelter Abhรคngigkeits-โ€žGraphenโ€œ (Bรคume).
!!! tip "Tipp"
/// tip | "Tipp"
All dies scheint angesichts dieser einfachen Beispiele mรถglicherweise nicht so nรผtzlich zu sein.
Aber Sie werden in den Kapiteln รผber **Sicherheit** sehen, wie nรผtzlich das ist.
Und Sie werden auch sehen, wie viel Code Sie dadurch einsparen.
///

13
docs/de/docs/tutorial/encoder.md

@ -20,23 +20,30 @@ Sie kรถnnen fรผr diese Fรคlle `jsonable_encoder` verwenden.
Es nimmt ein Objekt entgegen, wie etwa ein Pydantic-Modell, und gibt eine JSON-kompatible Version zurรผck:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="4 21"
{!> ../../../docs_src/encoder/tutorial001_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="5 22"
{!> ../../../docs_src/encoder/tutorial001.py!}
```
////
In diesem Beispiel wird das Pydantic-Modell in ein `dict`, und das `datetime`-Objekt in ein `str` konvertiert.
Das Resultat dieses Aufrufs ist etwas, das mit Pythons Standard-<a href="https://docs.python.org/3/library/json.html#json.dumps" class="external-link" target="_blank">`json.dumps()`</a> kodiert werden kann.
Es wird also kein groรŸer `str` zurรผckgegeben, der die Daten im JSON-Format (als String) enthรคlt. Es wird eine Python-Standarddatenstruktur (z. B. ein `dict`) zurรผckgegeben, mit Werten und Unterwerten, die alle mit JSON kompatibel sind.
!!! note "Hinweis"
/// note | "Hinweis"
`jsonable_encoder` wird tatsรคchlich von **FastAPI** intern verwendet, um Daten zu konvertieren. Aber es ist in vielen anderen Szenarien hilfreich.
///

60
docs/de/docs/tutorial/extra-data-types.md

@ -55,76 +55,108 @@ Hier sind einige der zusรคtzlichen Datentypen, die Sie verwenden kรถnnen:
Hier ist ein Beispiel fรผr eine *Pfadoperation* mit Parametern, die einige der oben genannten Typen verwenden.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1 3 12-16"
{!> ../../../docs_src/extra_data_types/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="1 3 12-16"
{!> ../../../docs_src/extra_data_types/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 3 13-17"
{!> ../../../docs_src/extra_data_types/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip
!!! tip
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1 2 11-15"
{!> ../../../docs_src/extra_data_types/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip
!!! tip
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1 2 12-16"
{!> ../../../docs_src/extra_data_types/tutorial001.py!}
```
////
Beachten Sie, dass die Parameter innerhalb der Funktion ihren natรผrlichen Datentyp haben und Sie beispielsweise normale Datumsmanipulationen durchfรผhren kรถnnen, wie zum Beispiel:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="18-19"
{!> ../../../docs_src/extra_data_types/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="18-19"
{!> ../../../docs_src/extra_data_types/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="19-20"
{!> ../../../docs_src/extra_data_types/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip
!!! tip
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17-18"
{!> ../../../docs_src/extra_data_types/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip
!!! tip
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="18-19"
{!> ../../../docs_src/extra_data_types/tutorial001.py!}
```
////

60
docs/de/docs/tutorial/extra-models.md

@ -8,32 +8,42 @@ Insbesondere Benutzermodelle, denn:
* Das **herausgehende Modell** sollte kein Passwort haben.
* Das **Datenbankmodell** sollte wahrscheinlich ein <abbr title='Ein aus scheinbar zufรคlligen Zeichen bestehender โ€žFingerabdruckโ€œ eines Textes. Der Inhalt des Textes kann nicht eingesehen werden.'>gehashtes</abbr> Passwort haben.
!!! danger "Gefahr"
/// danger | "Gefahr"
Speichern Sie niemals das Klartext-Passwort eines Benutzers. Speichern Sie immer den โ€žsicheren Hashโ€œ, den Sie verifizieren kรถnnen.
Falls Ihnen das nichts sagt, in den [Sicherheits-Kapiteln](security/simple-oauth2.md#passwort-hashing){.internal-link target=_blank} werden Sie lernen, was ein โ€žPasswort-Hashโ€œ ist.
///
## Mehrere Modelle
Hier der generelle Weg, wie die Modelle mit ihren Passwort-Feldern aussehen kรถnnten, und an welchen Orten sie verwendet werden wรผrden.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7 9 14 20 22 27-28 31-33 38-39"
{!> ../../../docs_src/extra_models/tutorial001_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9 11 16 22 24 29-30 33-35 40-41"
{!> ../../../docs_src/extra_models/tutorial001.py!}
```
!!! info
////
/// info
In Pydantic v1 hieรŸ diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstรผtzt) und in `.model_dump()` umbenannt.
Die Beispiele hier verwenden `.dict()` fรผr die Kompatibilitรคt mit Pydantic v1, Sie sollten jedoch stattdessen `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden kรถnnen.
///
### รœber `**user_in.dict()`
#### Pydantic's `.dict()`
@ -144,9 +154,12 @@ UserInDB(
)
```
!!! warning "Achtung"
/// warning | "Achtung"
Die Hilfsfunktionen `fake_password_hasher` und `fake_save_user` demonstrieren nur den mรถglichen Fluss der Daten und bieten natรผrlich keine echte Sicherheit.
///
## Verdopplung vermeiden
Reduzierung von Code-Verdoppelung ist eine der Kern-Ideen von **FastAPI**.
@ -163,18 +176,22 @@ Die ganze Datenkonvertierung, -validierung, -dokumentation, usw. wird immer noch
Auf diese Weise beschreiben wir nur noch die Unterschiede zwischen den Modellen (mit Klartext-`password`, mit `hashed_password`, und ohne Passwort):
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7 13-14 17-18 21-22"
{!> ../../../docs_src/extra_models/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9 15-16 19-20 23-24"
{!> ../../../docs_src/extra_models/tutorial002.py!}
```
////
## `Union`, oder `anyOf`
Sie kรถnnen deklarieren, dass eine Response eine <abbr title="Union โ€“ Verbund, Einheitโ€š Vereinigung: Eines von Mehreren">`Union`</abbr> mehrerer Typen ist, sprich, einer dieser Typen.
@ -183,21 +200,28 @@ Das wird in OpenAPI mit `anyOf` angezeigt.
Um das zu tun, verwenden Sie Pythons Standard-Typhinweis <a href="https://docs.python.org/3/library/typing.html#typing.Union" class="external-link" target="_blank">`typing.Union`</a>:
!!! note "Hinweis"
/// note | "Hinweis"
Listen Sie, wenn Sie eine <a href="https://pydantic-docs.helpmanual.io/usage/types/#unions" class="external-link" target="_blank">`Union`</a> definieren, denjenigen Typ zuerst, der am spezifischsten ist, gefolgt von den weniger spezifischen Typen. Im Beispiel oben, in `Union[PlaneItem, CarItem]` also den spezifischeren `PlaneItem` vor dem weniger spezifischen `CarItem`.
=== "Python 3.10+"
///
//// tab | Python 3.10+
```Python hl_lines="1 14-15 18-20 33"
{!> ../../../docs_src/extra_models/tutorial003_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 14-15 18-20 33"
{!> ../../../docs_src/extra_models/tutorial003.py!}
```
////
### `Union` in Python 3.10
In diesem Beispiel รผbergeben wir dem Argument `response_model` den Wert `Union[PlaneItem, CarItem]`.
@ -218,18 +242,22 @@ Genauso kรถnnen Sie eine Response deklarieren, die eine Liste von Objekten ist.
Verwenden Sie dafรผr Pythons Standard `typing.List` (oder nur `list` in Python 3.9 und darรผber):
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="18"
{!> ../../../docs_src/extra_models/tutorial004_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 20"
{!> ../../../docs_src/extra_models/tutorial004.py!}
```
////
## Response mit beliebigem `dict`
Sie kรถnne auch eine Response deklarieren, die ein beliebiges `dict` zurรผckgibt, bei dem nur die Typen der Schlรผssel und der Werte bekannt sind, ohne ein Pydantic-Modell zu verwenden.
@ -238,18 +266,22 @@ Das ist nรผtzlich, wenn Sie die gรผltigen Feld-/Attribut-Namen von vorneherein n
In diesem Fall kรถnnen Sie `typing.Dict` verwenden (oder nur `dict` in Python 3.9 und darรผber):
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="6"
{!> ../../../docs_src/extra_models/tutorial005_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1 8"
{!> ../../../docs_src/extra_models/tutorial005.py!}
```
////
## Zusammenfassung
Verwenden Sie gerne mehrere Pydantic-Modelle und vererben Sie je nach Bedarf.

30
docs/de/docs/tutorial/first-steps.md

@ -24,13 +24,16 @@ $ uvicorn main:app --reload
</div>
!!! note "Hinweis"
/// note | "Hinweis"
Der Befehl `uvicorn main:app` bezieht sich auf:
* `main`: die Datei `main.py` (das sogenannte Python-โ€žModulโ€œ).
* `app`: das Objekt, welches in der Datei `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde.
* `--reload`: lรคsst den Server nach Codeรคnderungen neu starten. Verwenden Sie das nur wรคhrend der Entwicklung.
///
In der Konsolenausgabe sollte es eine Zeile geben, die ungefรคhr so aussieht:
```hl_lines="4"
@ -136,11 +139,14 @@ Ebenfalls kรถnnen Sie es verwenden, um automatisch Code fรผr Clients zu generier
`FastAPI` ist eine Python-Klasse, die die gesamte Funktionalitรคt fรผr Ihre API bereitstellt.
!!! note "Technische Details"
/// note | "Technische Details"
`FastAPI` ist eine Klasse, die direkt von `Starlette` erbt.
Sie kรถnnen alle <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a>-Funktionalitรคten auch mit `FastAPI` nutzen.
///
### Schritt 2: Erzeugen einer `FastAPI`-โ€žInstanzโ€œ
```Python hl_lines="3"
@ -199,9 +205,12 @@ https://example.com/items/foo
/items/foo
```
!!! info
/// info
Ein โ€žPfadโ€œ wird hรคufig auch als โ€žEndpunktโ€œ oder โ€žRouteโ€œ bezeichnet.
///
Bei der Erstellung einer API ist der โ€žPfadโ€œ die wichtigste Mรถglichkeit zur Trennung von โ€žAnliegenโ€œ und โ€žRessourcenโ€œ.
#### Operation
@ -250,7 +259,8 @@ Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter fรผr die
* den Pfad `/`
* unter der Verwendung der <abbr title="eine HTTP GET Methode"><code>get</code>-Operation</abbr> gehen
!!! info "`@decorator` Information"
/// info | "`@decorator` Information"
Diese `@something`-Syntax wird in Python โ€žDekoratorโ€œ genannt.
Sie platzieren ihn รผber einer Funktion. Wie ein hรผbscher, dekorativer Hut (daher kommt wohl der Begriff).
@ -261,6 +271,8 @@ Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter fรผr die
Dies ist der โ€ž**Pfadoperation-Dekorator**โ€œ.
///
Sie kรถnnen auch die anderen Operationen verwenden:
* `@app.post()`
@ -274,7 +286,8 @@ Oder die exotischeren:
* `@app.patch()`
* `@app.trace()`
!!! tip "Tipp"
/// tip | "Tipp"
Es steht Ihnen frei, jede Operation (HTTP-Methode) so zu verwenden, wie Sie es mรถchten.
**FastAPI** erzwingt keine bestimmte Bedeutung.
@ -283,6 +296,8 @@ Oder die exotischeren:
Wenn Sie beispielsweise GraphQL verwenden, fรผhren Sie normalerweise alle Aktionen nur mit โ€žPOSTโ€œ-Operationen durch.
///
### Schritt 4: Definieren der **Pfadoperation-Funktion**
Das ist unsere โ€ž**Pfadoperation-Funktion**โ€œ:
@ -309,9 +324,12 @@ Sie kรถnnten sie auch als normale Funktion anstelle von `async def` definieren:
{!../../../docs_src/first_steps/tutorial003.py!}
```
!!! note "Hinweis"
/// note | "Hinweis"
Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *โ€žIn Eile?โ€œ*](../async.md#in-eile){.internal-link target=_blank}.
///
### Schritt 5: den Inhalt zurรผckgeben
```Python hl_lines="8"

20
docs/de/docs/tutorial/handling-errors.md

@ -63,13 +63,16 @@ Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existiere
}
```
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie eine `HTTPException` auslรถsen, kรถnnen Sie dem Parameter `detail` jeden Wert รผbergeben, der nach JSON konvertiert werden kann, nicht nur `str`.
Zum Beispiel ein `dict`, eine `list`, usw.
Das wird automatisch von **FastAPI** gehandhabt und der Wert nach JSON konvertiert.
///
## Benutzerdefinierte Header hinzufรผgen
Es gibt Situationen, da ist es nรผtzlich, dem HTTP-Error benutzerdefinierte Header hinzufรผgen zu kรถnnen, etwa in einigen Sicherheitsszenarien.
@ -106,11 +109,14 @@ Sie erhalten also einen sauberen Error mit einem Statuscode `418` und dem JSON-I
{"message": "Oops! yolo did something. There goes a rainbow..."}
```
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.requests import Request` und `from starlette.responses import JSONResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette. Das Gleiche gilt fรผr `Request`.
///
## Die Default-Exceptionhandler รผberschreiben
**FastAPI** hat einige Default-Exceptionhandler.
@ -160,9 +166,12 @@ path -> item_id
#### `RequestValidationError` vs. `ValidationError`
!!! warning "Achtung"
/// warning | "Achtung"
Das folgende sind technische Details, die Sie รผberspringen kรถnnen, wenn sie fรผr Sie nicht wichtig sind.
///
`RequestValidationError` ist eine Unterklasse von Pydantics <a href="https://pydantic-docs.helpmanual.io/usage/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
**FastAPI** verwendet diesen, sodass Sie, wenn Sie ein Pydantic-Modell fรผr `response_model` verwenden, und ihre Daten fehlerhaft sind, einen Fehler in ihrem Log sehen.
@ -183,11 +192,14 @@ Zum Beispiel kรถnnten Sie eine Klartext-Response statt JSON fรผr diese Fehler zu
{!../../../docs_src/handling_errors/tutorial004.py!}
```
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import PlainTextResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette.
///
### Den `RequestValidationError`-Body verwenden
Der `RequestValidationError` enthรคlt den empfangenen `body` mit den ungรผltigen Daten.

144
docs/de/docs/tutorial/header-params.md

@ -6,92 +6,130 @@ So wie `Query`-, `Path`-, und `Cookie`-Parameter kรถnnen Sie auch <abbr title='H
Importieren Sie zuerst `Header`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="3"
{!> ../../../docs_src/header_params/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="3"
{!> ../../../docs_src/header_params/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="3"
{!> ../../../docs_src/header_params/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/header_params/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3"
{!> ../../../docs_src/header_params/tutorial001.py!}
```
////
## `Header`-Parameter deklarieren
Dann deklarieren Sie Ihre Header-Parameter, auf die gleiche Weise, wie Sie auch `Path`-, `Query`-, und `Cookie`-Parameter deklarieren.
Der erste Wert ist der Typ. Sie kรถnnen `Header` die gehabten Extra Validierungs- und Beschreibungsparameter hinzufรผgen. Danach kรถnnen Sie einen Defaultwert vergeben:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10"
{!> ../../../docs_src/header_params/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/header_params/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial001.py!}
```
!!! note "Technische Details"
////
/// note | "Technische Details"
`Header` ist eine Schwesterklasse von `Path`, `Query` und `Cookie`. Sie erbt von derselben gemeinsamen `Param`-Elternklasse.
Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`, `Header` und andere von `fastapi` importieren, diese tatsรคchlich Funktionen sind, welche spezielle Klassen zurรผckgeben.
!!! info
///
/// info
Um Header zu deklarieren, mรผssen Sie `Header` verwenden, da diese Parameter sonst als Query-Parameter interpretiert werden wรผrden.
///
## Automatische Konvertierung
`Header` hat weitere Funktionalitรคt, zusรคtzlich zu der, die `Path`, `Query` und `Cookie` bereitstellen.
@ -108,45 +146,64 @@ Sie kรถnnen also `user_agent` schreiben, wie Sie es normalerweise in Python-Code
Wenn Sie aus irgendeinem Grund das automatische Konvertieren von Unterstrichen zu Bindestrichen abschalten mรถchten, setzen Sie den Parameter `convert_underscores` auf `False`.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="10"
{!> ../../../docs_src/header_params/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="11"
{!> ../../../docs_src/header_params/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12"
{!> ../../../docs_src/header_params/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8"
{!> ../../../docs_src/header_params/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10"
{!> ../../../docs_src/header_params/tutorial002.py!}
```
!!! warning "Achtung"
////
/// warning | "Achtung"
Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass manche HTTP-Proxys und Server die Verwendung von Headern mit Unterstrichen nicht erlauben.
///
## Doppelte Header
Es ist mรถglich, doppelte Header zu empfangen. Also den gleichen Header mit unterschiedlichen Werten.
@ -157,51 +214,72 @@ Sie erhalten dann alle Werte von diesem doppelten Header als Python-`list`e.
Um zum Beispiel einen Header `X-Token` zu deklarieren, der mehrmals vorkommen kann, schreiben Sie:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10"
{!> ../../../docs_src/header_params/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/header_params/tutorial003_py310.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial003_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9"
{!> ../../../docs_src/header_params/tutorial003.py!}
```
////
Wenn Sie mit einer *Pfadoperation* kommunizieren, die zwei HTTP-Header sendet, wie:
```

5
docs/de/docs/tutorial/index.md

@ -52,7 +52,8 @@ $ pip install "fastapi[all]"
... das beinhaltet auch `uvicorn`, welchen Sie als Server verwenden kรถnnen, der ihren Code ausfรผhrt.
!!! note "Hinweis"
/// note | "Hinweis"
Sie kรถnnen die einzelnen Teile auch separat installieren.
Das folgende wรผrden Sie wahrscheinlich tun, wenn Sie Ihre Anwendung in der Produktion einsetzen:
@ -69,6 +70,8 @@ $ pip install "fastapi[all]"
Das gleiche gilt fรผr jede der optionalen Abhรคngigkeiten, die Sie verwenden mรถchten.
///
## Handbuch fรผr fortgeschrittene Benutzer
Es gibt auch ein **Handbuch fรผr fortgeschrittene Benutzer**, welches Sie spรคter nach diesem **Tutorial โ€“ Benutzerhandbuch** lesen kรถnnen.

15
docs/de/docs/tutorial/metadata.md

@ -22,9 +22,12 @@ Sie kรถnnen diese wie folgt setzen:
{!../../../docs_src/metadata/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen Markdown in das Feld `description` schreiben und es wird in der Ausgabe gerendert.
///
Mit dieser Konfiguration wรผrde die automatische API-Dokumentation wie folgt aussehen:
<img src="/img/tutorial/metadata/image01.png">
@ -65,9 +68,12 @@ Erstellen Sie Metadaten fรผr Ihre Tags und รผbergeben Sie sie an den Parameter `
Beachten Sie, dass Sie Markdown in den Beschreibungen verwenden kรถnnen. Beispielsweise wird โ€žloginโ€œ in Fettschrift (**login**) und โ€žfancyโ€œ in Kursivschrift (_fancy_) angezeigt.
!!! tip "Tipp"
/// tip | "Tipp"
Sie mรผssen nicht fรผr alle von Ihnen verwendeten Tags Metadaten hinzufรผgen.
///
### Ihre Tags verwenden
Verwenden Sie den Parameter `tags` mit Ihren *Pfadoperationen* (und `APIRouter`n), um diese verschiedenen Tags zuzuweisen:
@ -76,9 +82,12 @@ Verwenden Sie den Parameter `tags` mit Ihren *Pfadoperationen* (und `APIRouter`n
{!../../../docs_src/metadata/tutorial004.py!}
```
!!! info
/// info
Lesen Sie mehr zu Tags unter [Pfadoperation-Konfiguration](path-operation-configuration.md#tags){.internal-link target=_blank}.
///
### Die Dokumentation anschauen
Wenn Sie nun die Dokumentation ansehen, werden dort alle zusรคtzlichen Metadaten angezeigt:

15
docs/de/docs/tutorial/middleware.md

@ -11,11 +11,14 @@ Eine โ€žMiddlewareโ€œ ist eine Funktion, die mit jedem **Request** arbeitet, bev
* Sie kann etwas mit dieser **Response** tun oder beliebigen Code ausfรผhren.
* Dann gibt sie die **Response** zurรผck.
!!! note "Technische Details"
/// note | "Technische Details"
Wenn Sie Abhรคngigkeiten mit `yield` haben, wird der Exit-Code *nach* der Middleware ausgefรผhrt.
Wenn es Hintergrundaufgaben gab (spรคter dokumentiert), werden sie *nach* allen Middlewares ausgefรผhrt.
///
## Erstellung einer Middleware
Um eine Middleware zu erstellen, verwenden Sie den Dekorator `@app.middleware("http")` รผber einer Funktion.
@ -32,16 +35,22 @@ Die Middleware-Funktion erhรคlt:
{!../../../docs_src/middleware/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass benutzerdefinierte proprietรคre Header hinzugefรผgt werden kรถnnen. <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">Verwenden Sie dafรผr das Prรคfix 'X-'</a>.
Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, mรผssen Sie sie zu Ihrer CORS-Konfigurationen ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufรผgen, indem Sie den Parameter `expose_headers` verwenden, der in der <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Starlette-CORS-Dokumentation</a> dokumentiert ist.
!!! note "Technische Details"
///
/// note | "Technische Details"
Sie kรถnnten auch `from starlette.requests import Request` verwenden.
**FastAPI** bietet es als Komfort fรผr Sie, den Entwickler, an. Aber es stammt direkt von Starlette.
///
### Vor und nach der `response`
Sie kรถnnen Code hinzufรผgen, der mit dem `request` ausgefรผhrt wird, bevor dieser von einer beliebigen *Pfadoperation* empfangen wird.

80
docs/de/docs/tutorial/path-operation-configuration.md

@ -2,9 +2,12 @@
Es gibt mehrere Konfigurations-Parameter, die Sie Ihrem *Pfadoperation-Dekorator* รผbergeben kรถnnen.
!!! warning "Achtung"
/// warning | "Achtung"
Beachten Sie, dass diese Parameter direkt dem *Pfadoperation-Dekorator* รผbergeben werden, nicht der *Pfadoperation-Funktion*.
///
## Response-Statuscode
Sie kรถnnen den (HTTP-)`status_code` definieren, den die Response Ihrer *Pfadoperation* verwenden soll.
@ -13,53 +16,68 @@ Sie kรถnnen direkt den `int`-Code รผbergeben, etwa `404`.
Aber falls Sie sich nicht mehr erinnern, wofรผr jede Nummer steht, kรถnnen Sie die Abkรผrzungs-Konstanten in `status` verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1 15"
{!> ../../../docs_src/path_operation_configuration/tutorial001_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="3 17"
{!> ../../../docs_src/path_operation_configuration/tutorial001_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="3 17"
{!> ../../../docs_src/path_operation_configuration/tutorial001.py!}
```
////
Dieser Statuscode wird in der Response verwendet und zum OpenAPI-Schema hinzugefรผgt.
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette import status` verwenden.
**FastAPI** bietet dieselben `starlette.status`-Codes auch via `fastapi.status` an, als Annehmlichkeit fรผr Sie, den Entwickler. Sie kommen aber direkt von Starlette.
///
## Tags
Sie kรถnnen Ihrer *Pfadoperation* Tags hinzufรผgen, mittels des Parameters `tags`, dem eine `list`e von `str`s รผbergeben wird (in der Regel nur ein `str`):
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="15 20 25"
{!> ../../../docs_src/path_operation_configuration/tutorial002_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="17 22 27"
{!> ../../../docs_src/path_operation_configuration/tutorial002_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17 22 27"
{!> ../../../docs_src/path_operation_configuration/tutorial002.py!}
```
////
Diese werden zum OpenAPI-Schema hinzugefรผgt und von den automatischen Dokumentations-Benutzeroberflรคchen verwendet:
<img src="/img/tutorial/path-operation-configuration/image01.png">
@ -80,48 +98,60 @@ In diesem Fall macht es Sinn, die Tags in einem `Enum` zu speichern.
Sie kรถnnen eine Zusammenfassung (`summary`) und eine Beschreibung (`description`) hinzufรผgen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="18-19"
{!> ../../../docs_src/path_operation_configuration/tutorial003_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="20-21"
{!> ../../../docs_src/path_operation_configuration/tutorial003_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20-21"
{!> ../../../docs_src/path_operation_configuration/tutorial003.py!}
```
////
## Beschreibung mittels Docstring
Da Beschreibungen oft mehrere Zeilen lang sind, kรถnnen Sie die Beschreibung der *Pfadoperation* im <abbr title="Ein mehrzeiliger String (keiner Variable zugewiesen) als erster Ausdruck in einer Funktion, wird fรผr die Dokumentation derselben verwendet">Docstring</abbr> der Funktion deklarieren, und **FastAPI** wird sie daraus auslesen.
Sie kรถnnen im Docstring <a href="https://en.wikipedia.org/wiki/Markdown" class="external-link" target="_blank">Markdown</a> schreiben, es wird korrekt interpretiert und angezeigt (die Einrรผckung des Docstring beachtend).
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="17-25"
{!> ../../../docs_src/path_operation_configuration/tutorial004_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="19-27"
{!> ../../../docs_src/path_operation_configuration/tutorial004_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="19-27"
{!> ../../../docs_src/path_operation_configuration/tutorial004.py!}
```
////
In der interaktiven Dokumentation sieht das dann so aus:
<img src="/img/tutorial/path-operation-configuration/image02.png">
@ -130,32 +160,44 @@ In der interaktiven Dokumentation sieht das dann so aus:
Die Response kรถnnen Sie mit dem Parameter `response_description` beschreiben:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19"
{!> ../../../docs_src/path_operation_configuration/tutorial005_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="21"
{!> ../../../docs_src/path_operation_configuration/tutorial005_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="21"
{!> ../../../docs_src/path_operation_configuration/tutorial005.py!}
```
!!! info
////
/// info
beachten Sie, dass sich `response_description` speziell auf die Response bezieht, wรคhrend `description` sich generell auf die *Pfadoperation* bezieht.
!!! check
///
/// check
OpenAPI verlangt, dass jede *Pfadoperation* รผber eine Beschreibung der Response verfรผgt.
Daher, wenn Sie keine vergeben, wird **FastAPI** automatisch eine fรผr โ€žErfolgreiche Responseโ€œ erstellen.
///
<img src="/img/tutorial/path-operation-configuration/image03.png">
## Eine *Pfadoperation* deprecaten

166
docs/de/docs/tutorial/path-params-numeric-validations.md

@ -6,103 +6,144 @@ So wie Sie mit `Query` fรผr Query-Parameter zusรคtzliche Validierungen und Metad
Importieren Sie zuerst `Path` von `fastapi`, und importieren Sie `Annotated`.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="1 3"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="1 3"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="3-4"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001.py!}
```
!!! info
////
/// info
FastAPI unterstรผtzt (und empfiehlt die Verwendung von) `Annotated` seit Version 0.95.0.
Wenn Sie eine รคltere Version haben, werden Sie Fehler angezeigt bekommen, wenn Sie versuchen, `Annotated` zu verwenden.
Bitte [aktualisieren Sie FastAPI](../deployment/versions.md#upgrade-der-fastapi-versionen){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden.
///
## Metadaten deklarieren
Sie kรถnnen die gleichen Parameter deklarieren wie fรผr `Query`.
Um zum Beispiel einen `title`-Metadaten-Wert fรผr den Pfad-Parameter `item_id` zu deklarieren, schreiben Sie:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="11"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial001.py!}
```
!!! note "Hinweis"
////
/// note | "Hinweis"
Ein Pfad-Parameter ist immer erforderlich, weil er Teil des Pfads sein muss.
Sie sollten ihn daher mit `...` deklarieren, um ihn als erforderlich auszuzeichnen.
Doch selbst wenn Sie ihn mit `None` deklarieren, oder einen Defaultwert setzen, bewirkt das nichts, er bleibt immer erforderlich.
///
## Sortieren Sie die Parameter, wie Sie mรถchten
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie `Annotated` verwenden, ist das folgende nicht so wichtig / nicht notwendig.
///
Nehmen wir an, Sie mรถchten den Query-Parameter `q` als erforderlichen `str` deklarieren.
Und Sie mรผssen sonst nichts anderes fรผr den Parameter deklarieren, Sie brauchen also nicht wirklich `Query`.
@ -117,34 +158,46 @@ Fรผr **FastAPI** ist es nicht wichtig. Es erkennt die Parameter anhand ihres Nam
Sie kรถnnen Ihre Funktion also so deklarieren:
=== "Python 3.8 nicht annotiert"
//// tab | Python 3.8 nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/path_params_numeric_validations/tutorial002.py!}
```
////
Aber bedenken Sie, dass Sie dieses Problem nicht haben, wenn Sie `Annotated` verwenden, da Sie nicht die Funktions-Parameter-Defaultwerte fรผr `Query()` oder `Path()` verwenden.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/path_params_numeric_validations/tutorial002_an.py!}
```
////
## Sortieren Sie die Parameter wie Sie mรถchten: Tricks
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie `Annotated` verwenden, ist das folgende nicht so wichtig / nicht notwendig.
///
Hier ein **kleiner Trick**, der nรผtzlich sein kann, aber Sie werden ihn nicht oft brauchen.
Wenn Sie eines der folgenden Dinge tun mรถchten:
@ -168,44 +221,57 @@ Python macht nichts mit diesem `*`, aber es wird wissen, dass alle folgenden Par
Bedenken Sie, dass Sie, wenn Sie `Annotated` verwenden, dieses Problem nicht haben, weil Sie keine Defaultwerte fรผr Ihre Funktionsparameter haben. Sie mรผssen daher wahrscheinlich auch nicht `*` verwenden.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/path_params_numeric_validations/tutorial003_an.py!}
```
////
## Validierung von Zahlen: GrรถรŸer oder gleich
Mit `Query` und `Path` (und anderen, die Sie spรคter kennenlernen), kรถnnen Sie Zahlenbeschrรคnkungen deklarieren.
Hier, mit `ge=1`, wird festgelegt, dass `item_id` eine Ganzzahl benรถtigt, die grรถรŸer oder gleich `1` ist (`g`reater than or `e`qual).
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/path_params_numeric_validations/tutorial004_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8"
{!> ../../../docs_src/path_params_numeric_validations/tutorial004.py!}
```
////
## Validierung von Zahlen: GrรถรŸer und kleiner oder gleich
Das Gleiche trifft zu auf:
@ -213,27 +279,36 @@ Das Gleiche trifft zu auf:
* `gt`: `g`reater `t`han โ€“ grรถรŸer als
* `le`: `l`ess than or `e`qual โ€“ kleiner oder gleich
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10"
{!> ../../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/path_params_numeric_validations/tutorial005_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9"
{!> ../../../docs_src/path_params_numeric_validations/tutorial005.py!}
```
////
## Validierung von Zahlen: Floats, grรถรŸer und kleiner
Zahlenvalidierung funktioniert auch fรผr <abbr title="Kommazahl">`float`</abbr>-Werte.
@ -244,27 +319,36 @@ Hier wird es wichtig, in der Lage zu sein, <abbr title="greater than โ€“ grรถรŸe
Das gleiche gilt fรผr <abbr title="less than โ€“ kleiner als"><code>lt</code></abbr>.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="13"
{!> ../../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12"
{!> ../../../docs_src/path_params_numeric_validations/tutorial006_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11"
{!> ../../../docs_src/path_params_numeric_validations/tutorial006.py!}
```
////
## Zusammenfassung
Mit `Query` und `Path` (und anderen, die Sie noch nicht gesehen haben) kรถnnen Sie Metadaten und Stringvalidierungen deklarieren, so wie in [Query-Parameter und Stringvalidierungen](query-params-str-validations.md){.internal-link target=_blank} beschrieben.
@ -276,12 +360,16 @@ Und Sie kรถnnen auch Validierungen fรผr Zahlen deklarieren:
* `lt`: `l`ess `t`han โ€“ kleiner als
* `le`: `l`ess than or `e`qual โ€“ kleiner oder gleich
!!! info
/// info
`Query`, `Path`, und andere Klassen, die Sie spรคter kennenlernen, sind Unterklassen einer allgemeinen `Param`-Klasse.
Sie alle teilen die gleichen Parameter fรผr zusรคtzliche Validierung und Metadaten, die Sie gesehen haben.
!!! note "Technische Details"
///
/// note | "Technische Details"
`Query`, `Path` und andere, die Sie von `fastapi` importieren, sind tatsรคchlich Funktionen.
Die, wenn sie aufgerufen werden, Instanzen der Klassen mit demselben Namen zurรผckgeben.
@ -291,3 +379,5 @@ Und Sie kรถnnen auch Validierungen fรผr Zahlen deklarieren:
Diese Funktionen existieren (statt die Klassen direkt zu verwenden), damit Ihr Editor keine Fehlermeldungen รผber ihre Typen ausgibt.
Auf diese Weise kรถnnen Sie Ihren Editor und Ihre Programmier-Tools verwenden, ohne besondere Einstellungen vornehmen zu mรผssen, um diese Fehlermeldungen stummzuschalten.
///

40
docs/de/docs/tutorial/path-params.md

@ -24,9 +24,12 @@ Sie kรถnnen den Typ eines Pfad-Parameters in der Argumentliste der Funktion dekl
In diesem Fall wird `item_id` als `int` deklariert, also als Ganzzahl.
!!! check
/// check
Dadurch erhalten Sie Editor-Unterstรผtzung innerhalb Ihrer Funktion, mit Fehlerprรผfungen, Codevervollstรคndigung, usw.
///
## Daten-<abbr title="Auch bekannt als: Serialisierung, Parsen, Marshalling">Konversion</abbr>
Wenn Sie dieses Beispiel ausfรผhren und Ihren Browser unter <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a> รถffnen, sehen Sie als Response:
@ -35,11 +38,14 @@ Wenn Sie dieses Beispiel ausfรผhren und Ihren Browser unter <a href="http://127.
{"item_id":3}
```
!!! check
/// check
Beachten Sie, dass der Wert, den Ihre Funktion erhรคlt und zurรผckgibt, die Zahl `3` ist, also ein `int`. Nicht der String `"3"`, also ein `str`.
Sprich, mit dieser Typdeklaration wird **FastAPI** die Anfrage automatisch <abbr title="Den String, der von einer HTTP Anfrage kommt, in Python-Objekte konvertieren">โ€žparsenโ€œ</abbr>.
///
## Datenvalidierung
Wenn Sie aber im Browser <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> besuchen, erhalten Sie eine hรผbsche HTTP-Fehlermeldung:
@ -65,24 +71,30 @@ Der Pfad-Parameter `item_id` hatte den Wert `"foo"`, was kein `int` ist.
Die gleiche Fehlermeldung wรผrde angezeigt werden, wenn Sie ein `float` (also eine Kommazahl) statt eines `int`s รผbergeben wรผrden, wie etwa in: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
!!! check
/// check
Sprich, mit der gleichen Python-Typdeklaration gibt Ihnen **FastAPI** Datenvalidierung.
Beachten Sie, dass die Fehlermeldung auch direkt die Stelle anzeigt, wo die Validierung nicht erfolgreich war.
Das ist unglaublich hilfreich, wenn Sie Code entwickeln und debuggen, welcher mit ihrer API interagiert.
///
## Dokumentation
Wenn Sie die Seite <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> in Ihrem Browser รถffnen, sehen Sie eine automatische, interaktive API-Dokumentation:
<img src="/img/tutorial/path-params/image01.png">
!!! check
/// check
Wiederum, mit dieser gleichen Python-Typdeklaration gibt Ihnen **FastAPI** eine automatische, interaktive Dokumentation (verwendet die Swagger-Benutzeroberflรคche).
Beachten Sie, dass der Pfad-Parameter dort als Ganzzahl deklariert ist.
///
## Nรผtzliche Standards. Alternative Dokumentation
Und weil das generierte Schema vom <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a>-Standard kommt, gibt es viele kompatible Tools.
@ -141,12 +153,18 @@ Erstellen Sie dann Klassen-Attribute mit festgelegten Werten, welches die erlaub
{!../../../docs_src/path_params/tutorial005.py!}
```
!!! info
/// info
<a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">Enumerationen (oder kurz Enums)</a> gibt es in Python seit Version 3.4.
!!! tip "Tipp"
///
/// tip | "Tipp"
Falls Sie sich fragen, was โ€žAlexNetโ€œ, โ€žResNetโ€œ und โ€žLeNetโ€œ ist, das sind Namen von <abbr title="Genau genommen, Deep-Learning-Modellarchitekturen">Modellen</abbr> fรผr maschinelles Lernen.
///
### Deklarieren Sie einen *Pfad-Parameter*
Dann erstellen Sie einen *Pfad-Parameter*, der als Typ die gerade erstellte Enum-Klasse hat (`ModelName`):
@ -181,9 +199,12 @@ Den tatsรคchlichen Wert (in diesem Fall ein `str`) erhalten Sie via `model_name.
{!../../../docs_src/path_params/tutorial005.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen den Wert `"lenet"` auรŸerdem mittels `ModelName.lenet.value` abrufen.
///
#### *Enum-Member* zurรผckgeben
Sie kรถnnen *Enum-Member* in ihrer *Pfadoperation* zurรผckgeben, sogar verschachtelt in einem JSON-Body (z. B. als `dict`).
@ -235,11 +256,14 @@ Sie verwenden das also wie folgt:
{!../../../docs_src/path_params/tutorial004.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Der Parameter kรถnnte einen fรผhrenden Schrรคgstrich (`/`) haben, wie etwa in `/home/johndoe/myfile.txt`.
In dem Fall wรคre die URL: `/files//home/johndoe/myfile.txt`, mit einem doppelten Schrรคgstrich (`//`) zwischen `files` und `home`.
///
## Zusammenfassung
In **FastAPI** erhalten Sie mittels kurzer, intuitiver Typdeklarationen:

493
docs/de/docs/tutorial/query-params-str-validations.md

File diff suppressed because it is too large

42
docs/de/docs/tutorial/query-params.md

@ -63,39 +63,50 @@ gehen, werden die Parameter-Werte Ihrer Funktion sein:
Auf die gleiche Weise kรถnnen Sie optionale Query-Parameter deklarieren, indem Sie deren Defaultwert auf `None` setzen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7"
{!> ../../../docs_src/query_params/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/query_params/tutorial002.py!}
```
////
In diesem Fall wird der Funktionsparameter `q` optional, und standardmรครŸig `None` sein.
!!! check
/// check
Beachten Sie auch, dass **FastAPI** intelligent genug ist, um zu erkennen, dass `item_id` ein Pfad-Parameter ist und `q` keiner, daher muss letzteres ein Query-Parameter sein.
///
## Query-Parameter Typkonvertierung
Sie kรถnnen auch `bool`-Typen deklarieren und sie werden konvertiert:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7"
{!> ../../../docs_src/query_params/tutorial003_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/query_params/tutorial003.py!}
```
////
Wenn Sie nun zu:
```
@ -136,18 +147,22 @@ Und Sie mรผssen sie auch nicht in einer spezifischen Reihenfolge deklarieren.
Parameter werden anhand ihres Namens erkannt:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="6 8"
{!> ../../../docs_src/query_params/tutorial004_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8 10"
{!> ../../../docs_src/query_params/tutorial004.py!}
```
////
## Erforderliche Query-Parameter
Wenn Sie einen Defaultwert fรผr Nicht-Pfad-Parameter deklarieren (Bis jetzt haben wir nur Query-Parameter gesehen), dann ist der Parameter nicht erforderlich.
@ -204,23 +219,30 @@ http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
Und natรผrlich kรถnnen Sie einige Parameter als erforderlich, einige mit Defaultwert, und einige als vollstรคndig optional definieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="8"
{!> ../../../docs_src/query_params/tutorial006_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10"
{!> ../../../docs_src/query_params/tutorial006.py!}
```
////
In diesem Fall gibt es drei Query-Parameter:
* `needy`, ein erforderlicher `str`.
* `skip`, ein `int` mit einem Defaultwert `0`.
* `limit`, ein optionales `int`.
!!! tip "Tipp"
/// tip | "Tipp"
Sie kรถnnen auch `Enum`s verwenden, auf die gleiche Weise wie mit [Pfad-Parametern](path-params.md#vordefinierte-parameterwerte){.internal-link target=_blank}.
///

190
docs/de/docs/tutorial/request-files.md

@ -2,71 +2,98 @@
Mit `File` kรถnnen sie vom Client hochzuladende Dateien definieren.
!!! info
/// info
Um hochgeladene Dateien zu empfangen, installieren Sie zuerst <a href="https://andrew-d.github.io/python-multipart/" class="external-link" target="_blank">`python-multipart`</a>.
Z. B. `pip install python-multipart`.
Das, weil hochgeladene Dateien als โ€žFormulardatenโ€œ gesendet werden.
///
## `File` importieren
Importieren Sie `File` und `UploadFile` von `fastapi`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="3"
{!> ../../../docs_src/request_files/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1"
{!> ../../../docs_src/request_files/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/request_files/tutorial001.py!}
```
////
## `File`-Parameter definieren
Erstellen Sie Datei-Parameter, so wie Sie es auch mit `Body` und `Form` machen wรผrden:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/request_files/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8"
{!> ../../../docs_src/request_files/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/request_files/tutorial001.py!}
```
!!! info
////
/// info
`File` ist eine Klasse, die direkt von `Form` erbt.
Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`, `File` und andere von `fastapi` importieren, diese tatsรคchlich Funktionen sind, welche spezielle Klassen zurรผckgeben
!!! tip "Tipp"
///
/// tip | "Tipp"
Um Dateibodys zu deklarieren, mรผssen Sie `File` verwenden, da diese Parameter sonst als Query-Parameter oder Body(-JSON)-Parameter interpretiert werden wรผrden.
///
Die Dateien werden als โ€žFormulardatenโ€œ hochgeladen.
Wenn Sie den Typ Ihrer *Pfadoperation-Funktion* als `bytes` deklarieren, wird **FastAPI** die Datei fรผr Sie auslesen, und Sie erhalten den Inhalt als `bytes`.
@ -79,27 +106,36 @@ Aber es gibt viele Fรคlle, in denen Sie davon profitieren, `UploadFile` zu verwe
Definieren Sie einen Datei-Parameter mit dem Typ `UploadFile`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="14"
{!> ../../../docs_src/request_files/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="13"
{!> ../../../docs_src/request_files/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="12"
{!> ../../../docs_src/request_files/tutorial001.py!}
```
////
`UploadFile` zu verwenden, hat mehrere Vorzรผge gegenรผber `bytes`:
* Sie mรผssen `File()` nicht als Parameter-Defaultwert verwenden.
@ -141,95 +177,132 @@ Wenn Sie sich innerhalb einer normalen `def`-*Pfadoperation-Funktion* befinden,
contents = myfile.file.read()
```
!!! note "Technische Details zu `async`"
/// note | "Technische Details zu `async`"
Wenn Sie die `async`-Methoden verwenden, fรผhrt **FastAPI** die Datei-Methoden in einem <abbr title="Mehrere unabhรคngige Kindprozesse">Threadpool</abbr> aus und erwartet sie.
!!! note "Technische Details zu Starlette"
///
/// note | "Technische Details zu Starlette"
**FastAPI**s `UploadFile` erbt direkt von **Starlette**s `UploadFile`, fรผgt aber ein paar notwendige Teile hinzu, um es kompatibel mit **Pydantic** und anderen Teilen von FastAPI zu machen.
///
## Was sind โ€žFormulardatenโ€œ
HTML-Formulare (`<form></form>`) senden die Daten in einer โ€žspeziellenโ€œ Kodierung zum Server, welche sich von JSON unterscheidet.
**FastAPI** stellt sicher, dass diese Daten korrekt ausgelesen werden, statt JSON zu erwarten.
!!! note "Technische Details"
/// note | "Technische Details"
Daten aus Formularen werden, wenn es keine Dateien sind, normalerweise mit dem <abbr title='Media type โ€“ Medientyp, Typ des Mediums'>โ€žmedia typeโ€œ</abbr> `application/x-www-form-urlencoded` kodiert.
Sollte das Formular aber Dateien enthalten, dann werden diese mit `multipart/form-data` kodiert. Wenn Sie `File` verwenden, wird **FastAPI** wissen, dass es die Dateien vom korrekten Teil des Bodys holen muss.
Wenn Sie mehr รผber Formularfelder und ihre Kodierungen lesen mรถchten, besuchen Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network โ€“ Mozilla-Entwickler-Netzwerk">MDN</abbr>-Webdokumentation fรผr <code>POST</code></a>.
!!! warning "Achtung"
///
/// warning | "Achtung"
Sie kรถnnen mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie kรถnnen nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert.
Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.
///
## Optionaler Datei-Upload
Sie kรถnnen eine Datei optional machen, indem Sie Standard-Typannotationen verwenden und den Defaultwert auf `None` setzen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9 17"
{!> ../../../docs_src/request_files/tutorial001_02_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="9 17"
{!> ../../../docs_src/request_files/tutorial001_02_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10 18"
{!> ../../../docs_src/request_files/tutorial001_02_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7 15"
{!> ../../../docs_src/request_files/tutorial001_02_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9 17"
{!> ../../../docs_src/request_files/tutorial001_02.py!}
```
////
## `UploadFile` mit zusรคtzlichen Metadaten
Sie kรถnnen auch `File()` zusammen mit `UploadFile` verwenden, um zum Beispiel zusรคtzliche Metadaten zu setzen:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="9 15"
{!> ../../../docs_src/request_files/tutorial001_03_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8 14"
{!> ../../../docs_src/request_files/tutorial001_03_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7 13"
{!> ../../../docs_src/request_files/tutorial001_03.py!}
```
////
## Mehrere Datei-Uploads
Es ist auch mรถglich, mehrere Dateien gleichzeitig hochzuladen.
@ -238,77 +311,108 @@ Diese werden demselben Formularfeld zugeordnet, welches mit den Formulardaten ge
Um das zu machen, deklarieren Sie eine Liste von `bytes` oder `UploadFile`s:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10 15"
{!> ../../../docs_src/request_files/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="11 16"
{!> ../../../docs_src/request_files/tutorial002_an.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8 13"
{!> ../../../docs_src/request_files/tutorial002_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10 15"
{!> ../../../docs_src/request_files/tutorial002.py!}
```
////
Sie erhalten, wie deklariert, eine `list`e von `bytes` oder `UploadFile`s.
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette.responses import HTMLResponse` verwenden.
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit fรผr Sie, den Entwickler. Die meisten verfรผgbaren Responses kommen aber direkt von Starlette.
///
### Mehrere Datei-Uploads mit zusรคtzlichen Metadaten
Und so wie zuvor kรถnnen Sie `File()` verwenden, um zusรคtzliche Parameter zu setzen, sogar fรผr `UploadFile`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="11 18-20"
{!> ../../../docs_src/request_files/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="12 19-21"
{!> ../../../docs_src/request_files/tutorial003_an.py!}
```
=== "Python 3.9+ nicht annotiert"
////
//// tab | Python 3.9+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="9 16"
{!> ../../../docs_src/request_files/tutorial003_py39.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="11 18"
{!> ../../../docs_src/request_files/tutorial003.py!}
```
////
## Zusammenfassung
Verwenden Sie `File`, `bytes` und `UploadFile`, um hochladbare Dateien im Request zu deklarieren, die als Formulardaten gesendet werden.

44
docs/de/docs/tutorial/request-forms-and-files.md

@ -2,68 +2,92 @@
Sie kรถnnen gleichzeitig Dateien und Formulardaten mit `File` und `Form` definieren.
!!! info
/// info
Um hochgeladene Dateien und/oder Formulardaten zu empfangen, installieren Sie zuerst <a href="https://andrew-d.github.io/python-multipart/" class="external-link" target="_blank">`python-multipart`</a>.
Z. B. `pip install python-multipart`.
///
## `File` und `Form` importieren
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="3"
{!> ../../../docs_src/request_forms_and_files/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1"
{!> ../../../docs_src/request_forms_and_files/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/request_forms_and_files/tutorial001.py!}
```
////
## `File` und `Form`-Parameter definieren
Erstellen Sie Datei- und Formularparameter, so wie Sie es auch mit `Body` und `Query` machen wรผrden:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="10-12"
{!> ../../../docs_src/request_forms_and_files/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9-11"
{!> ../../../docs_src/request_forms_and_files/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="8"
{!> ../../../docs_src/request_forms_and_files/tutorial001.py!}
```
////
Die Datei- und Formularfelder werden als Formulardaten hochgeladen, und Sie erhalten diese Dateien und Formularfelder.
Und Sie kรถnnen einige der Dateien als `bytes` und einige als `UploadFile` deklarieren.
!!! warning "Achtung"
/// warning | "Achtung"
Sie kรถnnen mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie kรถnnen nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert.
Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.
///
## Zusammenfassung
Verwenden Sie `File` und `Form` zusammen, wenn Sie Daten und Dateien zusammen im selben Request empfangen mรผssen.

59
docs/de/docs/tutorial/request-forms.md

@ -2,91 +2,124 @@
Wenn Sie Felder aus Formularen statt JSON empfangen mรผssen, kรถnnen Sie `Form` verwenden.
!!! info
/// info
Um Formulare zu verwenden, installieren Sie zuerst <a href="https://andrew-d.github.io/python-multipart/" class="external-link" target="_blank">`python-multipart`</a>.
Z. B. `pip install python-multipart`.
///
## `Form` importieren
Importieren Sie `Form` von `fastapi`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="3"
{!> ../../../docs_src/request_forms/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="1"
{!> ../../../docs_src/request_forms/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1"
{!> ../../../docs_src/request_forms/tutorial001.py!}
```
////
## `Form`-Parameter definieren
Erstellen Sie Formular-Parameter, so wie Sie es auch mit `Body` und `Query` machen wรผrden:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="9"
{!> ../../../docs_src/request_forms/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="8"
{!> ../../../docs_src/request_forms/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7"
{!> ../../../docs_src/request_forms/tutorial001.py!}
```
////
Zum Beispiel stellt eine der Mรถglichkeiten, die OAuth2 Spezifikation zu verwenden (genannt <abbr title='โ€žPasswort-Flussโ€œ'>โ€žpassword flowโ€œ</abbr>), die Bedingung, einen `username` und ein `password` als Formularfelder zu senden.
Die <abbr title="Specification โ€“ Spezifikation">Spec</abbr> erfordert, dass die Felder exakt `username` und `password` genannt werden und als Formularfelder, nicht JSON, gesendet werden.
Mit `Form` haben Sie die gleichen Konfigurationsmรถglichkeiten wie mit `Body` (und `Query`, `Path`, `Cookie`), inklusive Validierung, Beispielen, einem Alias (z. B. `user-name` statt `username`), usw.
!!! info
/// info
`Form` ist eine Klasse, die direkt von `Body` erbt.
!!! tip "Tipp"
///
/// tip | "Tipp"
Um Formularbodys zu deklarieren, verwenden Sie explizit `Form`, da diese Parameter sonst als Query-Parameter oder Body(-JSON)-Parameter interpretiert werden wรผrden.
///
## รœber โ€žFormularfelderโ€œ
HTML-Formulare (`<form></form>`) senden die Daten in einer โ€žspeziellenโ€œ Kodierung zum Server, welche sich von JSON unterscheidet.
**FastAPI** stellt sicher, dass diese Daten korrekt ausgelesen werden, statt JSON zu erwarten.
!!! note "Technische Details"
/// note | "Technische Details"
Daten aus Formularen werden normalerweise mit dem <abbr title='Media type โ€“ Medientyp, Typ des Mediums'>โ€žmedia typeโ€œ</abbr> `application/x-www-form-urlencoded` kodiert.
Wenn das Formular stattdessen Dateien enthรคlt, werden diese mit `multipart/form-data` kodiert. Im nรคchsten Kapitel erfahren Sie mehr รผber die Handhabung von Dateien.
Wenn Sie mehr รผber Formularfelder und ihre Kodierungen lesen mรถchten, besuchen Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network โ€“ Mozilla-Entwickler-Netzwerk">MDN</abbr>-Webdokumentation fรผr <code>POST</code></a>.
!!! warning "Achtung"
///
/// warning | "Achtung"
Sie kรถnnen mehrere `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie kรถnnen nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `application/x-www-form-urlencoded` statt `application/json` kodiert.
Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.
///
## Zusammenfassung
Verwenden Sie `Form`, um Eingabe-Parameter fรผr Formulardaten zu deklarieren.

178
docs/de/docs/tutorial/response-model.md

@ -4,24 +4,30 @@ Sie kรถnnen den Typ der <abbr title="Response โ€“ Antwort: Daten, die zum anfrag
Hierbei kรถnnen Sie **Typannotationen** genauso verwenden, wie Sie es bei Werten von Funktions-**Parametern** machen; verwenden Sie Pydantic-Modelle, Listen, Dicts und skalare Werte wie Nummern, Booleans, usw.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="16 21"
{!> ../../../docs_src/response_model/tutorial001_01_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="18 23"
{!> ../../../docs_src/response_model/tutorial001_01_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="18 23"
{!> ../../../docs_src/response_model/tutorial001_01.py!}
```
////
FastAPI wird diesen Rรผckgabetyp verwenden, um:
* Die zurรผckzugebenden Daten zu **validieren**.
@ -53,36 +59,48 @@ Sie kรถnnen `response_model` in jeder mรถglichen *Pfadoperation* verwenden:
* `@app.delete()`
* usw.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="17 22 24-27"
{!> ../../../docs_src/response_model/tutorial001_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="17 22 24-27"
{!> ../../../docs_src/response_model/tutorial001_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="17 22 24-27"
{!> ../../../docs_src/response_model/tutorial001.py!}
```
!!! note "Hinweis"
////
/// note | "Hinweis"
Beachten Sie, dass `response_model` ein Parameter der โ€žDekoratorโ€œ-Methode ist (`get`, `post`, usw.). Nicht der *Pfadoperation-Funktion*, so wie die anderen Parameter.
///
`response_model` nimmt denselben Typ entgegen, den Sie auch fรผr ein Pydantic-Modellfeld deklarieren wรผrden, also etwa ein Pydantic-Modell, aber es kann auch z. B. eine `list`e von Pydantic-Modellen sein, wie etwa `List[Item]`.
FastAPI wird dieses `response_model` nehmen, um die Daten zu dokumentieren, validieren, usw. und auch, um **die Ausgabedaten** entsprechend der Typdeklaration **zu konvertieren und filtern**.
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie in Ihrem Editor strikte Typchecks haben, mypy, usw., kรถnnen Sie den Funktions-Rรผckgabetyp als <abbr title='โ€žIrgend etwasโ€œ'>`Any`</abbr> deklarieren.
So sagen Sie dem Editor, dass Sie absichtlich *irgendetwas* zurรผckgeben. Aber FastAPI wird trotzdem die Dokumentation, Validierung, Filterung, usw. der Daten รผbernehmen, via `response_model`.
///
### `response_model`-Prioritรคt
Wenn sowohl Rรผckgabetyp als auch `response_model` deklariert sind, hat `response_model` die Prioritรคt und wird von FastAPI bevorzugt verwendet.
@ -95,91 +113,117 @@ Sie kรถnnen auch `response_model=None` verwenden, um das Erstellen eines Respons
Im Folgenden deklarieren wir ein `UserIn`-Modell; es enthรคlt ein Klartext-Passwort:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7 9"
{!> ../../../docs_src/response_model/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9 11"
{!> ../../../docs_src/response_model/tutorial002.py!}
```
!!! info
////
/// info
Um `EmailStr` zu verwenden, installieren Sie zuerst <a href="https://github.com/JoshData/python-email-validator" class="external-link" target="_blank">`email_validator`</a>.
Z. B. `pip install email-validator`
oder `pip install pydantic[email]`.
///
Wir verwenden dieses Modell, um sowohl unsere Eingabe- als auch Ausgabedaten zu deklarieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="16"
{!> ../../../docs_src/response_model/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="18"
{!> ../../../docs_src/response_model/tutorial002.py!}
```
////
Immer wenn jetzt ein Browser einen Benutzer mit Passwort erzeugt, gibt die API dasselbe Passwort in der Response zurรผck.
Hier ist das mรถglicherweise kein Problem, da es derselbe Benutzer ist, der das Passwort sendet.
Aber wenn wir dasselbe Modell fรผr eine andere *Pfadoperation* verwenden, kรถnnten wir das Passwort dieses Benutzers zu jedem Client schicken.
!!! danger "Gefahr"
/// danger | "Gefahr"
Speichern Sie niemals das Klartext-Passwort eines Benutzers, oder versenden Sie es in einer Response wie dieser, wenn Sie sich nicht der resultierenden Gefahren bewusst sind und nicht wissen, was Sie tun.
///
## Ausgabemodell hinzufรผgen
Wir kรถnnen stattdessen ein Eingabemodell mit dem Klartext-Passwort, und ein Ausgabemodell ohne das Passwort erstellen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9 11 16"
{!> ../../../docs_src/response_model/tutorial003_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9 11 16"
{!> ../../../docs_src/response_model/tutorial003.py!}
```
////
Obwohl unsere *Pfadoperation-Funktion* hier denselben `user` von der Eingabe zurรผckgibt, der das Passwort enthรคlt:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="24"
{!> ../../../docs_src/response_model/tutorial003_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="24"
{!> ../../../docs_src/response_model/tutorial003.py!}
```
////
... haben wir deklariert, dass `response_model` das Modell `UserOut` ist, welches das Passwort nicht enthรคlt:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="22"
{!> ../../../docs_src/response_model/tutorial003_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="22"
{!> ../../../docs_src/response_model/tutorial003.py!}
```
////
Darum wird **FastAPI** sich darum kรผmmern, dass alle Daten, die nicht im Ausgabemodell deklariert sind, herausgefiltert werden (mittels Pydantic).
### `response_model` oder Rรผckgabewert
@ -202,18 +246,22 @@ Aber in den meisten Fรคllen, wenn wir so etwas machen, wollen wir nur, dass das
Und in solchen Fรคllen kรถnnen wir Klassen und Vererbung verwenden, um Vorteil aus den Typannotationen in der Funktion zu ziehen, was vom Editor und von Tools besser unterstรผtzt wird, wรคhrend wir gleichzeitig FastAPIs **Datenfilterung** behalten.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7-10 13-14 18"
{!> ../../../docs_src/response_model/tutorial003_01_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9-13 15-16 20"
{!> ../../../docs_src/response_model/tutorial003_01.py!}
```
////
Damit erhalten wir Tool-Unterstรผtzung, vom Editor und mypy, da dieser Code hinsichtlich der Typen korrekt ist, aber wir erhalten auch die Datenfilterung von FastAPI.
Wie funktioniert das? Schauen wir uns das mal an. ๐Ÿค“
@ -278,18 +326,22 @@ Aber wenn Sie ein beliebiges anderes Objekt zurรผckgeben, das kein gรผltiger Pyd
Das gleiche wird passieren, wenn Sie eine <abbr title='Eine Union mehrerer Typen bedeutet: โ€žIrgendeiner dieser Typenโ€œ'>Union</abbr> mehrerer Typen haben, und einer oder mehrere sind nicht gรผltige Pydantic-Typen. Zum Beispiel funktioniert folgendes nicht ๐Ÿ’ฅ:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="8"
{!> ../../../docs_src/response_model/tutorial003_04_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="10"
{!> ../../../docs_src/response_model/tutorial003_04.py!}
```
////
... das scheitert, da die Typannotation kein Pydantic-Typ ist, und auch keine einzelne `Response`-Klasse, oder -Unterklasse, es ist eine Union (eines von beiden) von `Response` und `dict`.
### Responsemodell deaktivieren
@ -300,42 +352,52 @@ Aber Sie mรถchten dennoch den Rรผckgabetyp in der Funktion annotieren, um Unters
In diesem Fall kรถnnen Sie die Generierung des Responsemodells abschalten, indem Sie `response_model=None` setzen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7"
{!> ../../../docs_src/response_model/tutorial003_05_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="9"
{!> ../../../docs_src/response_model/tutorial003_05.py!}
```
////
Das bewirkt, dass FastAPI die Generierung des Responsemodells unterlรคsst, und damit kรถnnen Sie jede gewรผnschte Rรผckgabetyp-Annotation haben, ohne dass es Ihre FastAPI-Anwendung beeinflusst. ๐Ÿค“
## Parameter fรผr die Enkodierung des Responsemodells
Ihr Responsemodell kรถnnte Defaultwerte haben, wie:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="9 11-12"
{!> ../../../docs_src/response_model/tutorial004_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="11 13-14"
{!> ../../../docs_src/response_model/tutorial004_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="11 13-14"
{!> ../../../docs_src/response_model/tutorial004.py!}
```
////
* `description: Union[str, None] = None` (oder `str | None = None` in Python 3.10) hat einen Defaultwert `None`.
* `tax: float = 10.5` hat einen Defaultwert `10.5`.
* `tags: List[str] = []` hat eine leere Liste als Defaultwert: `[]`.
@ -348,24 +410,30 @@ Wenn Sie zum Beispiel Modelle mit vielen optionalen Attributen in einer NoSQL-Da
Sie kรถnnen den *Pfadoperation-Dekorator*-Parameter `response_model_exclude_unset=True` setzen:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="22"
{!> ../../../docs_src/response_model/tutorial004_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="24"
{!> ../../../docs_src/response_model/tutorial004_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="24"
{!> ../../../docs_src/response_model/tutorial004.py!}
```
////
Die Defaultwerte werden dann nicht in der Response enthalten sein, sondern nur die tatsรคchlich gesetzten Werte.
Wenn Sie also den Artikel mit der ID `foo` bei der *Pfadoperation* anfragen, wird (ohne die Defaultwerte) die Response sein:
@ -377,15 +445,22 @@ Wenn Sie also den Artikel mit der ID `foo` bei der *Pfadoperation* anfragen, wir
}
```
!!! info
/// info
In Pydantic v1 hieรŸ diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstรผtzt) und in `.model_dump()` umbenannt.
Die Beispiele hier verwenden `.dict()` fรผr die Kompatibilitรคt mit Pydantic v1, Sie sollten jedoch stattdessen `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden kรถnnen.
!!! info
///
/// info
FastAPI verwendet `.dict()` von Pydantic Modellen, <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">mit dessen `exclude_unset`-Parameter</a>, um das zu erreichen.
!!! info
///
/// info
Sie kรถnnen auch:
* `response_model_exclude_defaults=True`
@ -393,6 +468,8 @@ Wenn Sie also den Artikel mit der ID `foo` bei der *Pfadoperation* anfragen, wir
verwenden, wie in der <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">Pydantic Dokumentation</a> fรผr `exclude_defaults` und `exclude_none` beschrieben.
///
#### Daten mit Werten fรผr Felder mit Defaultwerten
Aber wenn ihre Daten Werte fรผr Modellfelder mit Defaultwerten haben, wie etwa der Artikel mit der ID `bar`:
@ -426,11 +503,14 @@ dann ist FastAPI klug genug (tatsรคchlich ist Pydantic klug genug) zu erkennen,
Diese Felder werden also in der JSON-Response enthalten sein.
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass Defaultwerte alles Mรถgliche sein kรถnnen, nicht nur `None`.
Sie kรถnnen eine Liste (`[]`), ein `float` `10.5`, usw. sein.
///
### `response_model_include` und `response_model_exclude`
Sie kรถnnen auch die Parameter `response_model_include` und `response_model_exclude` im **Pfadoperation-Dekorator** verwenden.
@ -439,46 +519,60 @@ Diese nehmen ein `set` von `str`s entgegen, welches Namen von Attributen sind, d
Das kann als schnelle Abkรผrzung verwendet werden, wenn Sie nur ein Pydantic-Modell haben und ein paar Daten von der Ausgabe ausschlieรŸen wollen.
!!! tip "Tipp"
/// tip | "Tipp"
Es wird dennoch empfohlen, dass Sie die Ideen von oben verwenden, also mehrere Klassen statt dieser Parameter.
Der Grund ist, dass das das generierte JSON-Schema in der OpenAPI ihrer Anwendung (und deren Dokumentation) dennoch das komplette Modell abbildet, selbst wenn Sie `response_model_include` oder `response_model_exclude` verwenden, um einige Attribute auszuschlieรŸen.
Das trifft auch auf `response_model_by_alias` zu, welches รคhnlich funktioniert.
=== "Python 3.10+"
///
//// tab | Python 3.10+
```Python hl_lines="29 35"
{!> ../../../docs_src/response_model/tutorial005_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="31 37"
{!> ../../../docs_src/response_model/tutorial005.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Die Syntax `{"name", "description"}` erzeugt ein `set` mit diesen zwei Werten.
ร„quivalent zu `set(["name", "description"])`.
///
#### `list`en statt `set`s verwenden
Wenn Sie vergessen, ein `set` zu verwenden, und stattdessen eine `list`e oder ein `tuple` รผbergeben, wird FastAPI die dennoch in ein `set` konvertieren, und es wird korrekt funktionieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="29 35"
{!> ../../../docs_src/response_model/tutorial006_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="31 37"
{!> ../../../docs_src/response_model/tutorial006.py!}
```
////
## Zusammenfassung
Verwenden Sie den Parameter `response_model` im *Pfadoperation-Dekorator*, um Responsemodelle zu definieren, und besonders, um private Daten herauszufiltern.

30
docs/de/docs/tutorial/response-status-code.md

@ -12,14 +12,20 @@ So wie ein Responsemodell, kรถnnen Sie auch einen HTTP-Statuscode fรผr die Respo
{!../../../docs_src/response_status_code/tutorial001.py!}
```
!!! note "Hinweis"
/// note | "Hinweis"
Beachten Sie, dass `status_code` ein Parameter der โ€žDekoratorโ€œ-Methode ist (`get`, `post`, usw.). Nicht der *Pfadoperation-Funktion*, so wie die anderen Parameter und der Body.
///
Dem `status_code`-Parameter wird eine Zahl mit dem HTTP-Statuscode รผbergeben.
!!! info
/// info
Alternativ kann `status_code` auch ein `IntEnum` erhalten, so wie Pythons <a href="https://docs.python.org/3/library/http.html#http.HTTPStatus" class="external-link" target="_blank">`http.HTTPStatus`</a>.
///
Das wird:
* Diesen Statuscode mit der Response zurรผcksenden.
@ -27,16 +33,22 @@ Das wird:
<img src="/img/tutorial/response-status-code/image01.png">
!!! note "Hinweis"
/// note | "Hinweis"
Einige Responsecodes (siehe nรคchster Abschnitt) kennzeichnen, dass die Response keinen Body hat.
FastAPI versteht das und wird in der OpenAPI-Dokumentation anzeigen, dass es keinen Responsebody gibt.
///
## รœber HTTP-Statuscodes
!!! note "Hinweis"
/// note | "Hinweis"
Wenn Sie bereits wissen, was HTTP-Statuscodes sind, รผberspringen Sie dieses Kapitel und fahren Sie mit dem nรคchsten fort.
///
In HTTP senden Sie als Teil der Response einen aus drei Ziffern bestehenden numerischen Statuscode.
Diese Statuscodes haben einen Namen zugeordnet, um sie besser zu erkennen, aber der wichtige Teil ist die Zahl.
@ -54,9 +66,12 @@ Kurz:
* Fรผr allgemeine Fehler beim Client kรถnnen Sie einfach `400` verwenden.
* `500` und darรผber stehen fรผr Server-Fehler. Diese verwenden Sie fast nie direkt. Wenn etwas an irgendeiner Stelle in Ihrem Anwendungscode oder im Server schieflรคuft, wird automatisch einer dieser Fehler-Statuscodes zurรผckgegeben.
!!! tip "Tipp"
/// tip | "Tipp"
Um mehr รผber Statuscodes zu lernen, und welcher wofรผr verwendet wird, lesen Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Status" class="external-link" target="_blank"><abbr title="Mozilla Developer Network โ€“ Mozilla-Entwickler-Netzwerk">MDN</abbr> Dokumentation รผber HTTP-Statuscodes</a>.
///
## Abkรผrzung, um die Namen zu erinnern
Schauen wir uns das vorherige Beispiel noch einmal an:
@ -79,11 +94,14 @@ Diese sind nur eine Annehmlichkeit und enthalten dieselbe Nummer, aber auf diese
<img src="/img/tutorial/response-status-code/image02.png">
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnen auch `from starlette import status` verwenden.
**FastAPI** bietet dieselben `starlette.status`-Codes auch via `fastapi.status` an, als Annehmlichkeit fรผr Sie, den Entwickler. Sie kommen aber direkt von Starlette.
///
## Den Defaultwert รคndern
Spรคter sehen Sie, im [Handbuch fรผr fortgeschrittene Benutzer](../advanced/response-change-status-code.md){.internal-link target=_blank}, wie Sie einen anderen Statuscode zurรผckgeben kรถnnen, als den Default, den Sie hier deklarieren.

152
docs/de/docs/tutorial/schema-extra-example.md

@ -8,72 +8,94 @@ Hier sind mehrere Mรถglichkeiten, das zu tun.
Sie kรถnnen `examples` (โ€žBeispieleโ€œ) fรผr ein Pydantic-Modell deklarieren, welche dem generierten JSON-Schema hinzugefรผgt werden.
=== "Python 3.10+ Pydantic v2"
//// tab | Python 3.10+ Pydantic v2
```Python hl_lines="13-24"
{!> ../../../docs_src/schema_extra_example/tutorial001_py310.py!}
```
=== "Python 3.10+ Pydantic v1"
////
//// tab | Python 3.10+ Pydantic v1
```Python hl_lines="13-23"
{!> ../../../docs_src/schema_extra_example/tutorial001_py310_pv1.py!}
```
=== "Python 3.8+ Pydantic v2"
////
//// tab | Python 3.8+ Pydantic v2
```Python hl_lines="15-26"
{!> ../../../docs_src/schema_extra_example/tutorial001.py!}
```
=== "Python 3.8+ Pydantic v1"
////
//// tab | Python 3.8+ Pydantic v1
```Python hl_lines="15-25"
{!> ../../../docs_src/schema_extra_example/tutorial001_pv1.py!}
```
////
Diese zusรคtzlichen Informationen werden unverรคndert zum fรผr dieses Modell ausgegebenen **JSON-Schema** hinzugefรผgt und in der API-Dokumentation verwendet.
=== "Pydantic v2"
//// tab | Pydantic v2
In Pydantic Version 2 wรผrden Sie das Attribut `model_config` verwenden, das ein `dict` akzeptiert, wie beschrieben in <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">Pydantic-Dokumentation: Configuration</a>.
Sie kรถnnen `json_schema_extra` setzen, mit einem `dict`, das alle zusรคtzlichen Daten enthรคlt, die im generierten JSON-Schema angezeigt werden sollen, einschlieรŸlich `examples`.
=== "Pydantic v1"
////
//// tab | Pydantic v1
In Pydantic Version 1 wรผrden Sie eine interne Klasse `Config` und `schema_extra` verwenden, wie beschrieben in <a href="https://docs.pydantic.dev/1.10/usage/schema/#schema-customization" class="external-link" target="_blank">Pydantic-Dokumentation: Schema customization</a>.
Sie kรถnnen `schema_extra` setzen, mit einem `dict`, das alle zusรคtzlichen Daten enthรคlt, die im generierten JSON-Schema angezeigt werden sollen, einschlieรŸlich `examples`.
!!! tip "Tipp"
////
/// tip | "Tipp"
Mit derselben Technik kรถnnen Sie das JSON-Schema erweitern und Ihre eigenen benutzerdefinierten Zusatzinformationen hinzufรผgen.
Sie kรถnnten das beispielsweise verwenden, um Metadaten fรผr eine Frontend-Benutzeroberflรคche usw. hinzuzufรผgen.
!!! info
///
/// info
OpenAPI 3.1.0 (verwendet seit FastAPI 0.99.0) hat Unterstรผtzung fรผr `examples` hinzugefรผgt, was Teil des **JSON Schema** Standards ist.
Zuvor unterstรผtzte es nur das Schlรผsselwort `example` mit einem einzigen Beispiel. Dieses wird weiterhin von OpenAPI 3.1.0 unterstรผtzt, ist jedoch <abbr title="deprecated โ€“ obsolet, veraltet: Es soll nicht mehr verwendet werden">deprecated</abbr> und nicht Teil des JSON Schema Standards. Wir empfehlen Ihnen daher, von `example` nach `examples` zu migrieren. ๐Ÿค“
Mehr erfahren Sie am Ende dieser Seite.
///
## Zusรคtzliche Argumente fรผr `Field`
Wenn Sie `Field()` mit Pydantic-Modellen verwenden, kรถnnen Sie ebenfalls zusรคtzliche `examples` deklarieren:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="2 8-11"
{!> ../../../docs_src/schema_extra_example/tutorial002_py310.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4 10-13"
{!> ../../../docs_src/schema_extra_example/tutorial002.py!}
```
////
## `examples` im JSON-Schema โ€“ OpenAPI
Bei Verwendung von:
@ -92,42 +114,58 @@ kรถnnen Sie auch eine Gruppe von `examples` mit zusรคtzlichen Informationen dekl
Hier รผbergeben wir `examples`, welches ein einzelnes Beispiel fรผr die in `Body()` erwarteten Daten enthรคlt:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="22-29"
{!> ../../../docs_src/schema_extra_example/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="22-29"
{!> ../../../docs_src/schema_extra_example/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="23-30"
{!> ../../../docs_src/schema_extra_example/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="18-25"
{!> ../../../docs_src/schema_extra_example/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="20-27"
{!> ../../../docs_src/schema_extra_example/tutorial003.py!}
```
////
### Beispiel in der Dokumentations-Benutzeroberflรคche
Mit jeder der oben genannten Methoden wรผrde es in `/docs` so aussehen:
@ -138,42 +176,58 @@ Mit jeder der oben genannten Methoden wรผrde es in `/docs` so aussehen:
Sie kรถnnen natรผrlich auch mehrere `examples` รผbergeben:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="23-38"
{!> ../../../docs_src/schema_extra_example/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="23-38"
{!> ../../../docs_src/schema_extra_example/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="24-39"
{!> ../../../docs_src/schema_extra_example/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19-34"
{!> ../../../docs_src/schema_extra_example/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="21-36"
{!> ../../../docs_src/schema_extra_example/tutorial004.py!}
```
////
Wenn Sie das tun, werden die Beispiele Teil des internen **JSON-Schemas** fรผr diese Body-Daten.
<abbr title="26.08.2023">Wรคhrend dies geschrieben wird</abbr>, unterstรผtzt Swagger UI, das fรผr die Anzeige der Dokumentations-Benutzeroberflรคche zustรคndige Tool, jedoch nicht die Anzeige mehrerer Beispiele fรผr die Daten in **JSON Schema**. Aber lesen Sie unten fรผr einen Workaround weiter.
@ -213,42 +267,58 @@ Jedes spezifische Beispiel-`dict` in den `examples` kann Folgendes enthalten:
Sie kรถnnen es so verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="23-49"
{!> ../../../docs_src/schema_extra_example/tutorial005_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="23-49"
{!> ../../../docs_src/schema_extra_example/tutorial005_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="24-50"
{!> ../../../docs_src/schema_extra_example/tutorial005_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19-45"
{!> ../../../docs_src/schema_extra_example/tutorial005_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="21-47"
{!> ../../../docs_src/schema_extra_example/tutorial005.py!}
```
////
### OpenAPI-Beispiele in der Dokumentations-Benutzeroberflรคche
Wenn `openapi_examples` zu `Body()` hinzugefรผgt wird, wรผrde `/docs` so aussehen:
@ -257,18 +327,24 @@ Wenn `openapi_examples` zu `Body()` hinzugefรผgt wird, wรผrde `/docs` so aussehe
## Technische Details
!!! tip "Tipp"
/// tip | "Tipp"
Wenn Sie bereits **FastAPI** Version **0.99.0 oder hรถher** verwenden, kรถnnen Sie diese Details wahrscheinlich **รผberspringen**.
Sie sind fรผr รคltere Versionen relevanter, bevor OpenAPI 3.1.0 verfรผgbar war.
Sie kรถnnen dies als eine kurze **Geschichtsstunde** zu OpenAPI und JSON Schema betrachten. ๐Ÿค“
!!! warning "Achtung"
///
/// warning | "Achtung"
Dies sind sehr technische Details zu den Standards **JSON Schema** und **OpenAPI**.
Wenn die oben genannten Ideen bereits fรผr Sie funktionieren, reicht das mรถglicherweise aus und Sie benรถtigen diese Details wahrscheinlich nicht, รผberspringen Sie sie gerne.
///
Vor OpenAPI 3.1.0 verwendete OpenAPI eine รคltere und modifizierte Version von **JSON Schema**.
JSON Schema hatte keine `examples`, daher fรผgte OpenAPI seiner eigenen modifizierten Version ein eigenes `example`-Feld hinzu.
@ -285,9 +361,12 @@ OpenAPI fรผgte auch die Felder `example` und `examples` zu anderen Teilen der Sp
* `File()`
* `Form()`
!!! info
/// info
Dieser alte, OpenAPI-spezifische `examples`-Parameter heiรŸt seit FastAPI `0.103.0` jetzt `openapi_examples`.
///
### JSON Schemas Feld `examples`
Aber dann fรผgte JSON Schema ein <a href="https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5" class="external-link" target="_blank">`examples`</a>-Feld zu einer neuen Version der Spezifikation hinzu.
@ -298,11 +377,14 @@ Und jetzt hat dieses neue `examples`-Feld Vorrang vor dem alten (und benutzerdef
Dieses neue `examples`-Feld in JSON Schema ist **nur eine `list`e** von Beispielen, kein Dict mit zusรคtzlichen Metadaten wie an den anderen Stellen in OpenAPI (oben beschrieben).
!!! info
/// info
Selbst, nachdem OpenAPI 3.1.0 verรถffentlicht wurde, mit dieser neuen, einfacheren Integration mit JSON Schema, unterstรผtzte Swagger UI, das Tool, das die automatische Dokumentation bereitstellt, eine Zeit lang OpenAPI 3.1.0 nicht (das tut es seit Version 5.0.0 ๐ŸŽ‰).
Aus diesem Grund verwendeten Versionen von FastAPI vor 0.99.0 immer noch Versionen von OpenAPI vor 3.1.0.
///
### Pydantic- und FastAPI-`examples`
Wenn Sie `examples` innerhalb eines Pydantic-Modells hinzufรผgen, indem Sie `schema_extra` oder `Field(examples=["something"])` verwenden, wird dieses Beispiel dem **JSON-Schema** fรผr dieses Pydantic-Modell hinzugefรผgt.

86
docs/de/docs/tutorial/security/first-steps.md

@ -20,36 +20,48 @@ Lassen Sie uns zunรคchst einfach den Code verwenden und sehen, wie er funktionie
Kopieren Sie das Beispiel in eine Datei `main.py`:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python
{!> ../../../docs_src/security/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python
{!> ../../../docs_src/security/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
{!> ../../../docs_src/security/tutorial001.py!}
```
////
## Ausfรผhren
!!! info
/// info
Um hochgeladene Dateien zu empfangen, installieren Sie zuerst <a href="https://andrew-d.github.io/python-multipart/" class="external-link" target="_blank">`python-multipart`</a>.
Z. B. `pip install python-multipart`.
Das, weil **OAuth2** โ€žFormulardatenโ€œ zum Senden von `username` und `password` verwendet.
///
Fรผhren Sie das Beispiel aus mit:
<div class="termy">
@ -70,18 +82,24 @@ Sie werden etwa Folgendes sehen:
<img src="/img/tutorial/security/image01.png">
!!! check "Authorize-Button!"
/// check | "Authorize-Button!"
Sie haben bereits einen glรคnzenden, neuen โ€žAuthorizeโ€œ-Button.
Und Ihre *Pfadoperation* hat in der oberen rechten Ecke ein kleines Schloss, auf das Sie klicken kรถnnen.
///
Und wenn Sie darauf klicken, erhalten Sie ein kleines Anmeldeformular zur Eingabe eines `username` und `password` (und anderer optionaler Felder):
<img src="/img/tutorial/security/image02.png">
!!! note "Hinweis"
/// note | "Hinweis"
Es spielt keine Rolle, was Sie in das Formular eingeben, es wird noch nicht funktionieren. Wir kommen dahin.
///
Dies ist natรผrlich nicht das Frontend fรผr die Endbenutzer, aber es ist ein groรŸartiges automatisches Tool, um Ihre gesamte API interaktiv zu dokumentieren.
Es kann vom Frontend-Team verwendet werden (das auch Sie selbst sein kรถnnen).
@ -122,7 +140,8 @@ Betrachten wir es also aus dieser vereinfachten Sicht:
In diesem Beispiel verwenden wir **OAuth2** mit dem **Password**-Flow und einem **Bearer**-Token. Wir machen das mit der Klasse `OAuth2PasswordBearer`.
!!! info
/// info
Ein โ€žBearerโ€œ-Token ist nicht die einzige Option.
Aber es ist die beste fรผr unseren Anwendungsfall.
@ -131,45 +150,62 @@ In diesem Beispiel verwenden wir **OAuth2** mit dem **Password**-Flow und einem
In dem Fall gibt Ihnen **FastAPI** ebenfalls die Tools, die Sie zum Erstellen brauchen.
///
Wenn wir eine Instanz der Klasse `OAuth2PasswordBearer` erstellen, รผbergeben wir den Parameter `tokenUrl`. Dieser Parameter enthรคlt die URL, die der Client (das Frontend, das im Browser des Benutzers ausgefรผhrt wird) verwendet, wenn er den `username` und das `password` sendet, um einen Token zu erhalten.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="8"
{!> ../../../docs_src/security/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="7"
{!> ../../../docs_src/security/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6"
{!> ../../../docs_src/security/tutorial001.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
Hier bezieht sich `tokenUrl="token"` auf eine relative URL `token`, die wir noch nicht erstellt haben. Da es sich um eine relative URL handelt, entspricht sie `./token`.
Da wir eine relative URL verwenden, wรผrde sich das, wenn sich Ihre API unter `https://example.com/` befindet, auf `https://example.com/token` beziehen. Wenn sich Ihre API jedoch unter `https://example.com/api/v1/` befรคnde, wรผrde es sich auf `https://example.com/api/v1/token` beziehen.
Die Verwendung einer relativen URL ist wichtig, um sicherzustellen, dass Ihre Anwendung auch in einem fortgeschrittenen Anwendungsfall, wie [hinter einem Proxy](../../advanced/behind-a-proxy.md){.internal-link target=_blank}, weiterhin funktioniert.
///
Dieser Parameter erstellt nicht diesen Endpunkt / diese *Pfadoperation*, sondern deklariert, dass die URL `/token` diejenige sein wird, die der Client verwenden soll, um den Token abzurufen. Diese Information wird in OpenAPI und dann in den interaktiven API-Dokumentationssystemen verwendet.
Wir werden demnรคchst auch die eigentliche Pfadoperation erstellen.
!!! info
/// info
Wenn Sie ein sehr strenger โ€žPythonistaโ€œ sind, missfรคllt Ihnen mรถglicherweise die Schreibweise des Parameternamens `tokenUrl` anstelle von `token_url`.
Das liegt daran, dass FastAPI denselben Namen wie in der OpenAPI-Spezifikation verwendet. Sodass Sie, wenn Sie mehr รผber eines dieser Sicherheitsschemas herausfinden mรถchten, den Namen einfach kopieren und einfรผgen kรถnnen, um weitere Informationen darรผber zu erhalten.
///
Die Variable `oauth2_scheme` ist eine Instanz von `OAuth2PasswordBearer`, aber auch ein โ€žCallableโ€œ.
Es kรถnnte wie folgt aufgerufen werden:
@ -184,36 +220,48 @@ Es kann also mit `Depends` verwendet werden.
Jetzt kรถnnen Sie dieses `oauth2_scheme` als Abhรคngigkeit `Depends` รผbergeben.
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="12"
{!> ../../../docs_src/security/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="11"
{!> ../../../docs_src/security/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10"
{!> ../../../docs_src/security/tutorial001.py!}
```
////
Diese Abhรคngigkeit stellt einen `str` bereit, der dem Parameter `token` der *Pfadoperation-Funktion* zugewiesen wird.
**FastAPI** weiรŸ, dass es diese Abhรคngigkeit verwenden kann, um ein โ€žSicherheitsschemaโ€œ im OpenAPI-Schema (und der automatischen API-Dokumentation) zu definieren.
!!! info "Technische Details"
/// info | "Technische Details"
**FastAPI** weiรŸ, dass es die Klasse `OAuth2PasswordBearer` (deklariert in einer Abhรคngigkeit) verwenden kann, um das Sicherheitsschema in OpenAPI zu definieren, da es von `fastapi.security.oauth2.OAuth2` erbt, das wiederum von `fastapi.security.base.SecurityBase` erbt.
Alle Sicherheits-Werkzeuge, die in OpenAPI integriert sind (und die automatische API-Dokumentation), erben von `SecurityBase`, so weiรŸ **FastAPI**, wie es sie in OpenAPI integrieren muss.
///
## Was es macht
FastAPI wird im Request nach diesem `Authorization`-Header suchen, prรผfen, ob der Wert `Bearer` plus ein Token ist, und den Token als `str` zurรผckgeben.

177
docs/de/docs/tutorial/security/get-current-user.md

@ -2,27 +2,36 @@
Im vorherigen Kapitel hat das Sicherheitssystem (das auf dem Dependency Injection System basiert) der *Pfadoperation-Funktion* einen `token` vom Typ `str` รผberreicht:
=== "Python 3.9+"
//// tab | Python 3.9+
```Python hl_lines="12"
{!> ../../../docs_src/security/tutorial001_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="11"
{!> ../../../docs_src/security/tutorial001_an.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="10"
{!> ../../../docs_src/security/tutorial001.py!}
```
////
Aber das ist immer noch nicht so nรผtzlich.
Lassen wir es uns den aktuellen Benutzer รผberreichen.
@ -33,42 +42,58 @@ Erstellen wir zunรคchst ein Pydantic-Benutzermodell.
So wie wir Pydantic zum Deklarieren von Bodys verwenden, kรถnnen wir es auch รผberall sonst verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="5 12-16"
{!> ../../../docs_src/security/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="5 12-16"
{!> ../../../docs_src/security/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="5 13-17"
{!> ../../../docs_src/security/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3 10-14"
{!> ../../../docs_src/security/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="5 12-16"
{!> ../../../docs_src/security/tutorial002.py!}
```
////
## Eine `get_current_user`-Abhรคngigkeit erstellen
Erstellen wir eine Abhรคngigkeit `get_current_user`.
@ -79,136 +104,190 @@ Erinnern Sie sich, dass Abhรคngigkeiten Unterabhรคngigkeiten haben kรถnnen?
So wie wir es zuvor in der *Pfadoperation* direkt gemacht haben, erhรคlt unsere neue Abhรคngigkeit `get_current_user` von der Unterabhรคngigkeit `oauth2_scheme` einen `token` vom Typ `str`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="25"
{!> ../../../docs_src/security/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="25"
{!> ../../../docs_src/security/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="26"
{!> ../../../docs_src/security/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="23"
{!> ../../../docs_src/security/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="25"
{!> ../../../docs_src/security/tutorial002.py!}
```
////
## Den Benutzer holen
`get_current_user` wird eine von uns erstellte (gefakte) Hilfsfunktion verwenden, welche einen Token vom Typ `str` entgegennimmt und unser Pydantic-`User`-Modell zurรผckgibt:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="19-22 26-27"
{!> ../../../docs_src/security/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="19-22 26-27"
{!> ../../../docs_src/security/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="20-23 27-28"
{!> ../../../docs_src/security/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="17-20 24-25"
{!> ../../../docs_src/security/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="19-22 26-27"
{!> ../../../docs_src/security/tutorial002.py!}
```
////
## Den aktuellen Benutzer einfรผgen
Und jetzt kรถnnen wir wiederum `Depends` mit unserem `get_current_user` in der *Pfadoperation* verwenden:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="31"
{!> ../../../docs_src/security/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="31"
{!> ../../../docs_src/security/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="32"
{!> ../../../docs_src/security/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="29"
{!> ../../../docs_src/security/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="31"
{!> ../../../docs_src/security/tutorial002.py!}
```
////
Beachten Sie, dass wir als Typ von `current_user` das Pydantic-Modell `User` deklarieren.
Das wird uns innerhalb der Funktion bei Codevervollstรคndigung und Typprรผfungen helfen.
!!! tip "Tipp"
/// tip | "Tipp"
Sie erinnern sich vielleicht, dass Requestbodys ebenfalls mit Pydantic-Modellen deklariert werden.
Weil Sie `Depends` verwenden, wird **FastAPI** hier aber nicht verwirrt.
!!! check
///
/// check
Die Art und Weise, wie dieses System von Abhรคngigkeiten konzipiert ist, ermรถglicht es uns, verschiedene Abhรคngigkeiten (verschiedene โ€žDependablesโ€œ) zu haben, die alle ein `User`-Modell zurรผckgeben.
Wir sind nicht darauf beschrรคnkt, nur eine Abhรคngigkeit zu haben, die diesen Typ von Daten zurรผckgeben kann.
///
## Andere Modelle
Sie kรถnnen jetzt den aktuellen Benutzer direkt in den *Pfadoperation-Funktionen* abrufen und die Sicherheitsmechanismen auf **Dependency Injection** Ebene handhaben, mittels `Depends`.
@ -241,42 +320,58 @@ Und alle (oder beliebige Teile davon) kรถnnen Vorteil ziehen aus der Wiederverwe
Und alle diese Tausenden von *Pfadoperationen* kรถnnen nur drei Zeilen lang sein:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="30-32"
{!> ../../../docs_src/security/tutorial002_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="30-32"
{!> ../../../docs_src/security/tutorial002_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="31-33"
{!> ../../../docs_src/security/tutorial002_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="28-30"
{!> ../../../docs_src/security/tutorial002_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="30-32"
{!> ../../../docs_src/security/tutorial002.py!}
```
////
## Zusammenfassung
Sie kรถnnen jetzt den aktuellen Benutzer direkt in Ihrer *Pfadoperation-Funktion* abrufen.

9
docs/de/docs/tutorial/security/index.md

@ -32,9 +32,11 @@ Heutzutage ist es nicht sehr populรคr und wird kaum verwendet.
OAuth2 spezifiziert nicht, wie die Kommunikation verschlรผsselt werden soll, sondern erwartet, dass Ihre Anwendung mit HTTPS bereitgestellt wird.
!!! tip "Tipp"
/// tip | "Tipp"
Im Abschnitt รผber **Deployment** erfahren Sie, wie Sie HTTPS mithilfe von Traefik und Let's Encrypt kostenlos einrichten.
///
## OpenID Connect
@ -87,11 +89,14 @@ OpenAPI definiert die folgenden Sicherheitsschemas:
* Diese automatische Erkennung ist es, die in der OpenID Connect Spezifikation definiert ist.
!!! tip "Tipp"
/// tip | "Tipp"
Auch die Integration anderer Authentifizierungs-/Autorisierungsanbieter wie Google, Facebook, Twitter, GitHub, usw. ist mรถglich und relativ einfach.
Das komplexeste Problem besteht darin, einen Authentifizierungs-/Autorisierungsanbieter wie solche aufzubauen, aber **FastAPI** reicht Ihnen die Tools, das einfach zu erledigen, wรคhrend Ihnen die schwere Arbeit abgenommen wird.
///
## **FastAPI** Tools
FastAPI stellt fรผr jedes dieser Sicherheitsschemas im Modul `fastapi.security` verschiedene Tools bereit, die die Verwendung dieser Sicherheitsmechanismen vereinfachen.

150
docs/de/docs/tutorial/security/oauth2-jwt.md

@ -44,11 +44,14 @@ $ pip install "python-jose[cryptography]"
Hier verwenden wir das empfohlene: <a href="https://cryptography.io/" class="external-link" target="_blank">pyca/cryptography</a>.
!!! tip "Tipp"
/// tip | "Tipp"
Dieses Tutorial verwendete zuvor <a href="https://pyjwt.readthedocs.io/" class="external-link" target="_blank">PyJWT</a>.
Es wurde jedoch aktualisiert, stattdessen python-jose zu verwenden, da dieses alle Funktionen von PyJWT sowie einige Extras bietet, die Sie spรคter mรถglicherweise benรถtigen, wenn Sie Integrationen mit anderen Tools erstellen.
///
## Passwort-Hashing
โ€žHashingโ€œ bedeutet: Konvertieren eines Inhalts (in diesem Fall eines Passworts) in eine Folge von Bytes (ein schlichter String), die wie Kauderwelsch aussieht.
@ -83,71 +86,96 @@ $ pip install "passlib[bcrypt]"
</div>
!!! tip "Tipp"
/// tip | "Tipp"
Mit `passlib` kรถnnen Sie sogar konfigurieren, Passwรถrter zu lesen, die von **Django**, einem **Flask**-Sicherheit-Plugin, oder vielen anderen erstellt wurden.
So kรถnnten Sie beispielsweise die gleichen Daten aus einer Django-Anwendung in einer Datenbank mit einer FastAPI-Anwendung teilen. Oder schrittweise eine Django-Anwendung migrieren, wรคhrend Sie dieselbe Datenbank verwenden.
Und Ihre Benutzer kรถnnten sich gleichzeitig รผber Ihre Django-Anwendung oder Ihre **FastAPI**-Anwendung anmelden.
///
## Die Passwรถrter hashen und รผberprรผfen
Importieren Sie die benรถtigten Tools aus `passlib`.
Erstellen Sie einen PassLib-โ€žKontextโ€œ. Der wird fรผr das Hashen und Verifizieren von Passwรถrtern verwendet.
!!! tip "Tipp"
/// tip | "Tipp"
Der PassLib-Kontext kann auch andere Hashing-Algorithmen verwenden, einschlieรŸlich deprecateter Alter, um etwa nur eine Verifizierung usw. zu ermรถglichen.
Sie kรถnnten ihn beispielsweise verwenden, um von einem anderen System (wie Django) generierte Passwรถrter zu lesen und zu verifizieren, aber alle neuen Passwรถrter mit einem anderen Algorithmus wie Bcrypt zu hashen.
Und mit allen gleichzeitig kompatibel sein.
///
Erstellen Sie eine Hilfsfunktion, um ein vom Benutzer stammendes Passwort zu hashen.
Und eine weitere, um zu รผberprรผfen, ob ein empfangenes Passwort mit dem gespeicherten Hash รผbereinstimmt.
Und noch eine, um einen Benutzer zu authentifizieren und zurรผckzugeben.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="7 48 55-56 59-60 69-75"
{!> ../../../docs_src/security/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="7 48 55-56 59-60 69-75"
{!> ../../../docs_src/security/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="7 49 56-57 60-61 70-76"
{!> ../../../docs_src/security/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6 47 54-55 58-59 68-74"
{!> ../../../docs_src/security/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="7 48 55-56 59-60 69-75"
{!> ../../../docs_src/security/tutorial004.py!}
```
!!! note "Hinweis"
////
/// note | "Hinweis"
Wenn Sie sich die neue (gefakte) Datenbank `fake_users_db` anschauen, sehen Sie, wie das gehashte Passwort jetzt aussieht: `"$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW"`.
///
## JWT-Token verarbeiten
Importieren Sie die installierten Module.
@ -176,42 +204,58 @@ Definieren Sie ein Pydantic-Modell, das im Token-Endpunkt fรผr die Response verw
Erstellen Sie eine Hilfsfunktion, um einen neuen Zugriffstoken zu generieren.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="6 12-14 28-30 78-86"
{!> ../../../docs_src/security/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="6 12-14 28-30 78-86"
{!> ../../../docs_src/security/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="6 13-15 29-31 79-87"
{!> ../../../docs_src/security/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="5 11-13 27-29 77-85"
{!> ../../../docs_src/security/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="6 12-14 28-30 78-86"
{!> ../../../docs_src/security/tutorial004.py!}
```
////
## Die Abhรคngigkeiten aktualisieren
Aktualisieren Sie `get_current_user`, um den gleichen Token wie zuvor zu erhalten, dieses Mal jedoch unter Verwendung von JWT-Tokens.
@ -220,84 +264,116 @@ Dekodieren Sie den empfangenen Token, validieren Sie ihn und geben Sie den aktue
Wenn der Token ungรผltig ist, geben Sie sofort einen HTTP-Fehler zurรผck.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="89-106"
{!> ../../../docs_src/security/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="89-106"
{!> ../../../docs_src/security/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="90-107"
{!> ../../../docs_src/security/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="88-105"
{!> ../../../docs_src/security/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="89-106"
{!> ../../../docs_src/security/tutorial004.py!}
```
////
## Die *Pfadoperation* `/token` aktualisieren
Erstellen Sie ein <abbr title="Zeitdifferenz">`timedelta`</abbr> mit der Ablaufzeit des Tokens.
Erstellen Sie einen echten JWT-Zugriffstoken und geben Sie ihn zurรผck.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="117-132"
{!> ../../../docs_src/security/tutorial004_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="117-132"
{!> ../../../docs_src/security/tutorial004_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="118-133"
{!> ../../../docs_src/security/tutorial004_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="114-129"
{!> ../../../docs_src/security/tutorial004_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="115-130"
{!> ../../../docs_src/security/tutorial004.py!}
```
////
### Technische Details zum JWT-โ€žSubjektโ€œ `sub`
Die JWT-Spezifikation besagt, dass es einen Schlรผssel `sub` mit dem Subjekt des Tokens gibt.
@ -335,9 +411,12 @@ Verwenden Sie die Anmeldeinformationen:
Benutzername: `johndoe`
Passwort: `secret`.
!!! check
/// check
Beachten Sie, dass im Code nirgendwo das Klartext-Passwort "`secret`" steht, wir haben nur die gehashte Version.
///
<img src="/img/tutorial/security/image08.png">
Rufen Sie den Endpunkt `/users/me/` auf, Sie erhalten die Response:
@ -357,9 +436,12 @@ Wenn Sie die Developer Tools รถffnen, kรถnnen Sie sehen, dass die gesendeten Dat
<img src="/img/tutorial/security/image10.png">
!!! note "Hinweis"
/// note | "Hinweis"
Beachten Sie den Header `Authorization` mit einem Wert, der mit `Bearer` beginnt.
///
## Fortgeschrittene Verwendung mit `scopes`
OAuth2 hat ein Konzept von <abbr title="Geltungsbereiche">โ€žScopesโ€œ</abbr>.

190
docs/de/docs/tutorial/security/simple-oauth2.md

@ -32,7 +32,8 @@ Diese werden normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu
* `instagram_basic` wird von Facebook / Instagram verwendet.
* `https://www.googleapis.com/auth/drive` wird von Google verwendet.
!!! info
/// info
In OAuth2 ist ein โ€žScopeโ€œ nur ein String, der eine bestimmte erforderliche Berechtigung deklariert.
Es spielt keine Rolle, ob er andere Zeichen wie `:` enthรคlt oder ob es eine URL ist.
@ -41,6 +42,8 @@ Diese werden normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu
Fรผr OAuth2 sind es einfach nur Strings.
///
## Code, um `username` und `password` entgegenzunehmen.
Lassen Sie uns nun die von **FastAPI** bereitgestellten Werkzeuge verwenden, um das zu erledigen.
@ -49,42 +52,58 @@ Lassen Sie uns nun die von **FastAPI** bereitgestellten Werkzeuge verwenden, um
Importieren Sie zunรคchst `OAuth2PasswordRequestForm` und verwenden Sie es als Abhรคngigkeit mit `Depends` in der *Pfadoperation* fรผr `/token`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="4 78"
{!> ../../../docs_src/security/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="4 78"
{!> ../../../docs_src/security/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="4 79"
{!> ../../../docs_src/security/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="2 74"
{!> ../../../docs_src/security/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="4 76"
{!> ../../../docs_src/security/tutorial003.py!}
```
////
`OAuth2PasswordRequestForm` ist eine Klassenabhรคngigkeit, die einen Formularbody deklariert mit:
* Dem `username`.
@ -92,15 +111,19 @@ Importieren Sie zunรคchst `OAuth2PasswordRequestForm` und verwenden Sie es als A
* Einem optionalen `scope`-Feld als langem String, bestehend aus durch Leerzeichen getrennten Strings.
* Einem optionalen `grant_type` (โ€žArt der Anmeldungโ€œ).
!!! tip "Tipp"
/// tip | "Tipp"
Die OAuth2-Spezifikation *erfordert* tatsรคchlich ein Feld `grant_type` mit dem festen Wert `password`, aber `OAuth2PasswordRequestForm` erzwingt dies nicht.
Wenn Sie es erzwingen mรผssen, verwenden Sie `OAuth2PasswordRequestFormStrict` anstelle von `OAuth2PasswordRequestForm`.
///
* Eine optionale `client_id` (benรถtigen wir fรผr unser Beispiel nicht).
* Ein optionales `client_secret` (benรถtigen wir fรผr unser Beispiel nicht).
!!! info
/// info
`OAuth2PasswordRequestForm` ist keine spezielle Klasse fรผr **FastAPI**, so wie `OAuth2PasswordBearer`.
`OAuth2PasswordBearer` lรคsst **FastAPI** wissen, dass es sich um ein Sicherheitsschema handelt. Daher wird es auf diese Weise zu OpenAPI hinzugefรผgt.
@ -109,55 +132,76 @@ Importieren Sie zunรคchst `OAuth2PasswordRequestForm` und verwenden Sie es als A
Da es sich jedoch um einen hรคufigen Anwendungsfall handelt, wird er zur Vereinfachung direkt von **FastAPI** bereitgestellt.
///
### Die Formulardaten verwenden
!!! tip "Tipp"
/// tip | "Tipp"
Die Instanz der Klassenabhรคngigkeit `OAuth2PasswordRequestForm` verfรผgt, statt eines Attributs `scope` mit dem durch Leerzeichen getrennten langen String, รผber das Attribut `scopes` mit einer tatsรคchlichen Liste von Strings, einem fรผr jeden gesendeten Scope.
In diesem Beispiel verwenden wir keine `scopes`, aber die Funktionalitรคt ist vorhanden, wenn Sie sie benรถtigen.
///
Rufen Sie nun die Benutzerdaten aus der (gefakten) Datenbank ab, fรผr diesen `username` aus dem Formularfeld.
Wenn es keinen solchen Benutzer gibt, geben wir die Fehlermeldung โ€žIncorrect username or passwordโ€œ zurรผck.
Fรผr den Fehler verwenden wir die Exception `HTTPException`:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="3 79-81"
{!> ../../../docs_src/security/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="3 79-81"
{!> ../../../docs_src/security/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="3 80-82"
{!> ../../../docs_src/security/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="1 75-77"
{!> ../../../docs_src/security/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="3 77-79"
{!> ../../../docs_src/security/tutorial003.py!}
```
////
### Das Passwort รผberprรผfen
Zu diesem Zeitpunkt liegen uns die Benutzerdaten aus unserer Datenbank vor, das Passwort haben wir jedoch noch nicht รผberprรผft.
@ -182,42 +226,58 @@ Wenn Ihre Datenbank gestohlen wird, hat der Dieb nicht die Klartext-Passwรถrter
Der Dieb kann also nicht versuchen, die gleichen Passwรถrter in einem anderen System zu verwenden (da viele Benutzer รผberall das gleiche Passwort verwenden, wรคre dies gefรคhrlich).
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="82-85"
{!> ../../../docs_src/security/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="82-85"
{!> ../../../docs_src/security/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="83-86"
{!> ../../../docs_src/security/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="78-81"
{!> ../../../docs_src/security/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="80-83"
{!> ../../../docs_src/security/tutorial003.py!}
```
////
#### รœber `**user_dict`
`UserInDB(**user_dict)` bedeutet:
@ -234,9 +294,12 @@ UserInDB(
)
```
!!! info
/// info
Eine ausfรผhrlichere Erklรคrung von `**user_dict` finden Sie in [der Dokumentation fรผr **Extra Modelle**](../extra-models.md#uber-user_indict){.internal-link target=_blank}.
///
## Den Token zurรผckgeben
Die Response des `token`-Endpunkts muss ein JSON-Objekt sein.
@ -247,48 +310,68 @@ Und es sollte einen `access_token` haben, mit einem String, der unseren Zugriffs
In diesem einfachen Beispiel gehen wir einfach vรถllig unsicher vor und geben denselben `username` wie der Token zurรผck.
!!! tip "Tipp"
/// tip | "Tipp"
Im nรคchsten Kapitel sehen Sie eine wirklich sichere Implementierung mit Passwort-Hashing und <abbr title="JSON Web Tokens">JWT</abbr>-Tokens.
Aber konzentrieren wir uns zunรคchst auf die spezifischen Details, die wir benรถtigen.
=== "Python 3.10+"
///
//// tab | Python 3.10+
```Python hl_lines="87"
{!> ../../../docs_src/security/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="87"
{!> ../../../docs_src/security/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="88"
{!> ../../../docs_src/security/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="83"
{!> ../../../docs_src/security/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="85"
{!> ../../../docs_src/security/tutorial003.py!}
```
!!! tip "Tipp"
////
/// tip | "Tipp"
GemรครŸ der Spezifikation sollten Sie ein JSON mit einem `access_token` und einem `token_type` zurรผckgeben, genau wie in diesem Beispiel.
Das mรผssen Sie selbst in Ihrem Code tun und sicherstellen, dass Sie diese JSON-Schlรผssel verwenden.
@ -297,6 +380,8 @@ In diesem einfachen Beispiel gehen wir einfach vรถllig unsicher vor und geben de
Den Rest erledigt **FastAPI** fรผr Sie.
///
## Die Abhรคngigkeiten aktualisieren
Jetzt werden wir unsere Abhรคngigkeiten aktualisieren.
@ -309,43 +394,60 @@ Beide Abhรคngigkeiten geben nur dann einen HTTP-Error zurรผck, wenn der Benutzer
In unserem Endpunkt erhalten wir also nur dann einen Benutzer, wenn der Benutzer existiert, korrekt authentifiziert wurde und aktiv ist:
=== "Python 3.10+"
//// tab | Python 3.10+
```Python hl_lines="58-66 69-74 94"
{!> ../../../docs_src/security/tutorial003_an_py310.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python hl_lines="58-66 69-74 94"
{!> ../../../docs_src/security/tutorial003_an_py39.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python hl_lines="59-67 70-75 95"
{!> ../../../docs_src/security/tutorial003_an.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="56-64 67-70 88"
{!> ../../../docs_src/security/tutorial003_py310.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python hl_lines="58-66 69-72 90"
{!> ../../../docs_src/security/tutorial003.py!}
```
!!! info
////
/// info
Der zusรคtzliche Header `WWW-Authenticate` mit dem Wert `Bearer`, den wir hier zurรผckgeben, ist ebenfalls Teil der Spezifikation.
Jeder HTTP-(Fehler-)Statuscode 401 โ€žUNAUTHORIZEDโ€œ soll auch einen `WWW-Authenticate`-Header zurรผckgeben.
@ -360,6 +462,8 @@ In unserem Endpunkt erhalten wir also nur dann einen Benutzer, wenn der Benutzer
Das ist der Vorteil von Standards ...
///
## Es in Aktion sehen
ร–ffnen Sie die interaktive Dokumentation: <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.

5
docs/de/docs/tutorial/static-files.md

@ -11,11 +11,14 @@ Mit `StaticFiles` kรถnnen Sie statische Dateien aus einem Verzeichnis automatisc
{!../../../docs_src/static_files/tutorial001.py!}
```
!!! note "Technische Details"
/// note | "Technische Details"
Sie kรถnnten auch `from starlette.staticfiles import StaticFiles` verwenden.
**FastAPI** stellt dasselbe `starlette.staticfiles` auch via `fastapi.staticfiles` bereit, als Annehmlichkeit fรผr Sie, den Entwickler. Es kommt aber tatsรคchlich direkt von Starlette.
///
### Was ist โ€žMountenโ€œ?
โ€žMountenโ€œ bedeutet das Hinzufรผgen einer vollstรคndigen โ€žunabhรคngigenโ€œ Anwendung an einem bestimmten Pfad, die sich dann um die Handhabung aller Unterpfade kรผmmert.

55
docs/de/docs/tutorial/testing.md

@ -8,11 +8,14 @@ Damit kรถnnen Sie <a href="https://docs.pytest.org/" class="external-link" targe
## Verwendung von `TestClient`
!!! info
/// info
Um `TestClient` zu verwenden, installieren Sie zunรคchst <a href="https://www.python-httpx.org" class="external-link" target="_blank">`httpx`</a>.
Z. B. `pip install httpx`.
///
Importieren Sie `TestClient`.
Erstellen Sie einen `TestClient`, indem Sie ihm Ihre **FastAPI**-Anwendung รผbergeben.
@ -27,21 +30,30 @@ Schreiben Sie einfache `assert`-Anweisungen mit den Standard-Python-Ausdrรผcken,
{!../../../docs_src/app_testing/tutorial001.py!}
```
!!! tip "Tipp"
/// tip | "Tipp"
Beachten Sie, dass die Testfunktionen normal `def` und nicht `async def` sind.
Und die Anrufe an den Client sind ebenfalls normale Anrufe, die nicht `await` verwenden.
Dadurch kรถnnen Sie `pytest` ohne Komplikationen direkt nutzen.
!!! note "Technische Details"
///
/// note | "Technische Details"
Sie kรถnnten auch `from starlette.testclient import TestClient` verwenden.
**FastAPI** stellt denselben `starlette.testclient` auch via `fastapi.testclient` bereit, als Annehmlichkeit fรผr Sie, den Entwickler. Es kommt aber tatsรคchlich direkt von Starlette.
!!! tip "Tipp"
///
/// tip | "Tipp"
Wenn Sie in Ihren Tests neben dem Senden von Anfragen an Ihre FastAPI-Anwendung auch `async`-Funktionen aufrufen mรถchten (z. B. asynchrone Datenbankfunktionen), werfen Sie einen Blick auf die [Async-Tests](../advanced/async-tests.md){.internal-link target=_blank} im Handbuch fรผr fortgeschrittene Benutzer.
///
## Tests separieren
In einer echten Anwendung wรผrden Sie Ihre Tests wahrscheinlich in einer anderen Datei haben.
@ -110,42 +122,58 @@ Sie verfรผgt รผber eine `POST`-Operation, die mehrere Fehler zurรผckgeben kรถnnt
Beide *Pfadoperationen* erfordern einen `X-Token`-Header.
=== "Python 3.10+"
//// tab | Python 3.10+
```Python
{!> ../../../docs_src/app_testing/app_b_an_py310/main.py!}
```
=== "Python 3.9+"
////
//// tab | Python 3.9+
```Python
{!> ../../../docs_src/app_testing/app_b_an_py39/main.py!}
```
=== "Python 3.8+"
////
//// tab | Python 3.8+
```Python
{!> ../../../docs_src/app_testing/app_b_an/main.py!}
```
=== "Python 3.10+ nicht annotiert"
////
//// tab | Python 3.10+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
{!> ../../../docs_src/app_testing/app_b_py310/main.py!}
```
=== "Python 3.8+ nicht annotiert"
////
//// tab | Python 3.8+ nicht annotiert
/// tip | "Tipp"
!!! tip "Tipp"
Bevorzugen Sie die `Annotated`-Version, falls mรถglich.
///
```Python
{!> ../../../docs_src/app_testing/app_b/main.py!}
```
////
### Erweiterte Testdatei
AnschlieรŸend kรถnnten Sie `test_main.py` mit den erweiterten Tests aktualisieren:
@ -168,11 +196,14 @@ Z. B.:
Weitere Informationen zum รœbergeben von Daten an das Backend (mithilfe von `httpx` oder dem `TestClient`) finden Sie in der <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX-Dokumentation</a>.
!!! info
/// info
Beachten Sie, dass der `TestClient` Daten empfรคngt, die nach JSON konvertiert werden kรถnnen, keine Pydantic-Modelle.
Wenn Sie ein Pydantic-Modell in Ihrem Test haben und dessen Daten wรคhrend des Testens an die Anwendung senden mรถchten, kรถnnen Sie den `jsonable_encoder` verwenden, der in [JSON-kompatibler Encoder](encoder.md){.internal-link target=_blank} beschrieben wird.
///
## Tests ausfรผhren
Danach mรผssen Sie nur noch `pytest` installieren:

25
docs/em/docs/advanced/additional-responses.md

@ -1,10 +1,13 @@
# ๐ŸŒ– ๐Ÿ“จ ๐Ÿ—„
!!! warning
/// warning
๐Ÿ‘‰ ๐Ÿ‘ ๐Ÿง โ”.
๐Ÿšฅ ๐Ÿ‘† โ–ถ๏ธ โฎ๏ธ **FastAPI**, ๐Ÿ‘† ๐Ÿ’ช ๐Ÿšซ ๐Ÿ’ช ๐Ÿ‘‰.
///
๐Ÿ‘† ๐Ÿ’ช ๐Ÿ“ฃ ๐ŸŒ– ๐Ÿ“จ, โฎ๏ธ ๐ŸŒ– ๐Ÿ‘” ๐Ÿ“Ÿ, ๐Ÿ”‰ ๐Ÿ†Ž, ๐Ÿ“›, โ™’๏ธ.
๐Ÿ‘ˆ ๐ŸŒ– ๐Ÿ“จ ๐Ÿ”œ ๐Ÿ”Œ ๐Ÿ—„ ๐Ÿ”—, ๐Ÿ‘ซ ๐Ÿ”œ ๐Ÿ˜‘ ๐Ÿ› ๏ธ ๐Ÿฉบ.
@ -27,10 +30,14 @@
{!../../../docs_src/additional_responses/tutorial001.py!}
```
!!! note
/// note
โœ”๏ธ ๐Ÿคฏ ๐Ÿ‘ˆ ๐Ÿ‘† โœ”๏ธ ๐Ÿ“จ `JSONResponse` ๐Ÿ”—.
!!! info
///
/// info
`model` ๐Ÿ”‘ ๐Ÿšซ ๐Ÿ• ๐Ÿ—„.
**FastAPI** ๐Ÿ”œ โœŠ Pydantic ๐Ÿท โšช๏ธโžก๏ธ ๐Ÿ“ค, ๐Ÿ— `JSON Schema`, &amp; ๐Ÿšฎ โšซ๏ธ โ˜‘ ๐Ÿฅ‰.
@ -42,6 +49,8 @@
* ๐Ÿ”‘ `schema`, ๐Ÿ‘ˆ โœ”๏ธ ๐Ÿ’ฒ ๐ŸŽป ๐Ÿ”— โšช๏ธโžก๏ธ ๐Ÿท, ๐Ÿ“ฅ โ˜‘ ๐Ÿฅ‰.
* **FastAPI** ๐Ÿšฎ ๐Ÿ”— ๐Ÿ“ฅ ๐ŸŒ ๐ŸŽป ๐Ÿ”— โž•1๏ธโƒฃ ๐Ÿฅ‰ ๐Ÿ‘† ๐Ÿ—„ โ†ฉ๏ธ โœ… โšซ๏ธ ๐Ÿ”—. ๐Ÿ‘‰ ๐ŸŒŒ, ๐ŸŽ ๐Ÿˆธ &amp; ๐Ÿ‘ฉโ€๐Ÿ’ป ๐Ÿ’ช โš™๏ธ ๐Ÿ‘ˆ ๐ŸŽป ๐Ÿ”— ๐Ÿ”—, ๐Ÿšš ๐Ÿ‘ป ๐Ÿ“Ÿ โšก ๐Ÿงฐ, โ™’๏ธ.
///
๐Ÿ— ๐Ÿ“จ ๐Ÿ—„ ๐Ÿ‘‰ *โžก ๐Ÿ› ๏ธ* ๐Ÿ”œ:
```JSON hl_lines="3-12"
@ -172,14 +181,20 @@
{!../../../docs_src/additional_responses/tutorial002.py!}
```
!!! note
/// note
๐Ÿ‘€ ๐Ÿ‘ˆ ๐Ÿ‘† โœ”๏ธ ๐Ÿ“จ ๐Ÿ–ผ โš™๏ธ `FileResponse` ๐Ÿ”—.
!!! info
///
/// info
๐Ÿšฅ ๐Ÿ‘† โœ” ๐ŸŽ ๐Ÿ“ป ๐Ÿ†Ž ๐ŸŽฏ ๐Ÿ‘† `responses` ๐Ÿ”ข, FastAPI ๐Ÿ”œ ๐Ÿค” ๐Ÿ“จ โœ”๏ธ ๐ŸŽ ๐Ÿ“ป ๐Ÿ†Ž ๐Ÿ‘‘ ๐Ÿ“จ ๐ŸŽ“ (๐Ÿ”ข `application/json`).
โœ‹๏ธ ๐Ÿšฅ ๐Ÿ‘† โœ”๏ธ โœ” ๐Ÿ›ƒ ๐Ÿ“จ ๐ŸŽ“ โฎ๏ธ `None` ๐Ÿšฎ ๐Ÿ“ป ๐Ÿ†Ž, FastAPI ๐Ÿ”œ โš™๏ธ `application/json` ๐Ÿ™† ๐ŸŒ– ๐Ÿ“จ ๐Ÿ‘ˆ โœ”๏ธ ๐Ÿ‘จโ€๐Ÿ’ผ ๐Ÿท.
///
## ๐ŸŒ€ โ„น
๐Ÿ‘† ๐Ÿ’ช ๐ŸŒ€ ๐Ÿ“จ โ„น โšช๏ธโžก๏ธ ๐Ÿ’— ๐Ÿฅ‰, ๐Ÿ”Œ `response_model`, `status_code`, &amp; `responses` ๐Ÿ”ข.

10
docs/em/docs/advanced/additional-status-codes.md

@ -18,18 +18,24 @@
{!../../../docs_src/additional_status_codes/tutorial001.py!}
```
!!! warning
/// warning
๐Ÿ•โ” ๐Ÿ‘† ๐Ÿ“จ `Response` ๐Ÿ”—, ๐Ÿ’– ๐Ÿ–ผ ๐Ÿ”›, โšซ๏ธ ๐Ÿ”œ ๐Ÿ“จ ๐Ÿ”—.
โšซ๏ธ ๐Ÿ† ๐Ÿšซ ๐ŸŽป โฎ๏ธ ๐Ÿท, โ™’๏ธ.
โš’ ๐Ÿ’ญ โšซ๏ธ โœ”๏ธ ๐Ÿ“Š ๐Ÿ‘† ๐Ÿ’š โšซ๏ธ โœ”๏ธ, &amp; ๐Ÿ‘ˆ ๐Ÿ’ฒ โ˜‘ ๐ŸŽป (๐Ÿšฅ ๐Ÿ‘† โš™๏ธ `JSONResponse`).
!!! note "๐Ÿ“ก โ„น"
///
/// note | "๐Ÿ“ก โ„น"
๐Ÿ‘† ๐Ÿ’ช โš™๏ธ `from starlette.responses import JSONResponse`.
**FastAPI** ๐Ÿšš ๐ŸŽ `starlette.responses` `fastapi.responses` ๐Ÿช ๐Ÿ‘†, ๐Ÿ‘ฉโ€๐Ÿ’ป. โœ‹๏ธ ๐ŸŒ… ๐Ÿ’ช ๐Ÿ“จ ๐Ÿ‘Ÿ ๐Ÿ”— โšช๏ธโžก๏ธ ๐Ÿ’ƒ. ๐ŸŽ โฎ๏ธ `status`.
///
## ๐Ÿ—„ &amp; ๐Ÿ› ๏ธ ๐Ÿฉบ
๐Ÿšฅ ๐Ÿ‘† ๐Ÿ“จ ๐ŸŒ– ๐Ÿ‘” ๐Ÿ“Ÿ &amp; ๐Ÿ“จ ๐Ÿ”—, ๐Ÿ‘ซ ๐Ÿ† ๐Ÿšซ ๐Ÿ”Œ ๐Ÿ—„ ๐Ÿ”— (๐Ÿ› ๏ธ ๐Ÿฉบ), โ†ฉ๏ธ FastAPI ๐Ÿšซ โœ”๏ธ ๐ŸŒŒ ๐Ÿ’ญ โช โšซ๏ธโ” ๐Ÿ‘† ๐Ÿšถ ๐Ÿ“จ.

5
docs/em/docs/advanced/advanced-dependencies.md

@ -60,7 +60,8 @@ checker(q="somequery")
{!../../../docs_src/dependencies/tutorial011.py!}
```
!!! tip
/// tip
๐ŸŒ ๐Ÿ‘‰ ๐Ÿ’ช ๐Ÿ˜‘ ๐ŸŽญ. &amp; โšซ๏ธ ๐Ÿ’ช ๐Ÿšซ ๐Ÿ“ถ ๐Ÿ†‘ โ” โšซ๏ธ โš .
๐Ÿ‘ซ ๐Ÿ–ผ ๐Ÿ˜ซ ๐Ÿ™…, โœ‹๏ธ ๐ŸŽฆ โ” โšซ๏ธ ๐ŸŒ ๐Ÿ‘ท.
@ -68,3 +69,5 @@ checker(q="somequery")
๐Ÿ“ƒ ๐Ÿ”ƒ ๐Ÿ’‚โ€โ™‚, ๐Ÿ“ค ๐Ÿš™ ๐Ÿ”ข ๐Ÿ‘ˆ ๐Ÿ› ๏ธ ๐Ÿ‘‰ ๐ŸŽ ๐ŸŒŒ.
๐Ÿšฅ ๐Ÿ‘† ๐Ÿค” ๐ŸŒ ๐Ÿ‘‰, ๐Ÿ‘† โช ๐Ÿ’ญ โ” ๐Ÿ‘ˆ ๐Ÿš™ ๐Ÿงฐ ๐Ÿ’‚โ€โ™‚ ๐Ÿ‘ท ๐Ÿ”˜.
///

15
docs/em/docs/advanced/async-tests.md

@ -64,9 +64,12 @@ $ pytest
{!../../../docs_src/async_tests/test_main.py!}
```
!!! tip
/// tip
๐Ÿ—’ ๐Ÿ‘ˆ ๐Ÿ’ฏ ๐Ÿ”ข ๐Ÿ”œ `async def` โ†ฉ๏ธ `def` โญ ๐Ÿ•โ” โš™๏ธ `TestClient`.
///
โคด๏ธ ๐Ÿ‘ฅ ๐Ÿ’ช โœ `AsyncClient` โฎ๏ธ ๐Ÿ“ฑ, &amp; ๐Ÿ“จ ๐Ÿ” ๐Ÿ“จ โšซ๏ธ, โš™๏ธ `await`.
```Python hl_lines="9-10"
@ -81,12 +84,18 @@ response = client.get('/')
...๐Ÿ‘ˆ ๐Ÿ‘ฅ โš™๏ธ โš’ ๐Ÿ‘† ๐Ÿ“จ โฎ๏ธ `TestClient`.
!!! tip
/// tip
๐Ÿ—’ ๐Ÿ‘ˆ ๐Ÿ‘ฅ โš™๏ธ ๐Ÿ”/โŒ› โฎ๏ธ ๐Ÿ†• `AsyncClient` - ๐Ÿ“จ ๐Ÿ”.
///
## ๐ŸŽ ๐Ÿ” ๐Ÿ”ข ๐Ÿค™
๐Ÿ”ฌ ๐Ÿ”ข ๐Ÿ”œ ๐Ÿ”, ๐Ÿ‘† ๐Ÿ’ช ๐Ÿ”œ ๐Ÿค™ (&amp; `await`) ๐ŸŽ `async` ๐Ÿ”ข โ†–๏ธ โšช๏ธโžก๏ธ ๐Ÿ“จ ๐Ÿ“จ ๐Ÿ‘† FastAPI ๐Ÿˆธ ๐Ÿ‘† ๐Ÿ’ฏ, โšซ๏ธโ” ๐Ÿ‘† ๐Ÿ”œ ๐Ÿค™ ๐Ÿ‘ซ ๐Ÿ™† ๐Ÿ™† ๐Ÿ‘† ๐Ÿ“Ÿ.
!!! tip
/// tip
๐Ÿšฅ ๐Ÿ‘† โš” `RuntimeError: Task attached to a different loop` ๐Ÿ•โ” ๐Ÿ› ๏ธ ๐Ÿ” ๐Ÿ”ข ๐Ÿค™ ๐Ÿ‘† ๐Ÿ’ฏ (โœ… ๐Ÿ•โ” โš™๏ธ <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">โœณ MotorClient</a>) ๐Ÿ’ญ ๐Ÿ”— ๐ŸŽš ๐Ÿ‘ˆ ๐Ÿ’ช ๐ŸŽ‰ โžฐ ๐Ÿ•ด ๐Ÿž ๐Ÿ” ๐Ÿ”ข, โœ… `'@app.on_event("startup")` โฒ.
///

35
docs/em/docs/advanced/behind-a-proxy.md

@ -39,9 +39,12 @@ browser --> proxy
proxy --> server
```
!!! tip
/// tip
๐Ÿ“ข `0.0.0.0` ๐Ÿ›Ž โš™๏ธ โ›“ ๐Ÿ‘ˆ ๐Ÿ“‹ ๐Ÿ‘‚ ๐Ÿ”› ๐ŸŒ ๐Ÿ“ข ๐Ÿ’ช ๐Ÿ‘ˆ ๐ŸŽฐ/๐Ÿ’ฝ.
///
๐Ÿฉบ ๐ŸŽš ๐Ÿ”œ ๐Ÿ’ช ๐Ÿ—„ ๐Ÿ”— ๐Ÿ“ฃ ๐Ÿ‘ˆ ๐Ÿ‘‰ ๐Ÿ› ๏ธ `server` ๐Ÿ”Ž `/api/v1` (โ›… ๐Ÿ—ณ). ๐Ÿ–ผ:
```JSON hl_lines="4-8"
@ -77,11 +80,14 @@ $ uvicorn main:app --root-path /api/v1
๐Ÿšฅ ๐Ÿ‘† โš™๏ธ Hypercorn, โšซ๏ธ โœ”๏ธ ๐ŸŽ› `--root-path`.
!!! note "๐Ÿ“ก โ„น"
/// note | "๐Ÿ“ก โ„น"
๐Ÿ”ซ ๐Ÿ”ง ๐Ÿ”ฌ `root_path` ๐Ÿ‘‰ โš™๏ธ ๐Ÿ’ผ.
&amp; `--root-path` ๐Ÿ“‹ โธ ๐ŸŽ› ๐Ÿšš ๐Ÿ‘ˆ `root_path`.
///
### โœ… โฎ๏ธ `root_path`
๐Ÿ‘† ๐Ÿ’ช ๐Ÿคš โฎ๏ธ `root_path` โš™๏ธ ๐Ÿ‘† ๐Ÿˆธ ๐Ÿ”  ๐Ÿ“จ, โšซ๏ธ ๐Ÿ• `scope` ๐Ÿ“– (๐Ÿ‘ˆ ๐Ÿ• ๐Ÿ”ซ ๐Ÿ”Œ).
@ -168,9 +174,12 @@ Uvicorn ๐Ÿ”œ โŒ› ๐Ÿ—ณ ๐Ÿ” Uvicorn `http://127.0.0.1:8000/app`, &amp; โคด๏ธ โšซ
๐Ÿ‘‰ ๐Ÿ’ฌ Traefik ๐Ÿ‘‚ ๐Ÿ”› โ›ด 9๏ธโƒฃ9๏ธโƒฃ9๏ธโƒฃ9๏ธโƒฃ &amp; โš™๏ธ โž•1๏ธโƒฃ ๐Ÿ“ `routes.toml`.
!!! tip
/// tip
๐Ÿ‘ฅ โš™๏ธ โ›ด 9๏ธโƒฃ9๏ธโƒฃ9๏ธโƒฃ9๏ธโƒฃ โ†ฉ๏ธ ๐Ÿฉ ๐Ÿ‡บ๐Ÿ‡ธ๐Ÿ” โ›ด 8๏ธโƒฃ0๏ธโƒฃ ๐Ÿ‘ˆ ๐Ÿ‘† ๐Ÿšซ โœ”๏ธ ๐Ÿƒ โšซ๏ธ โฎ๏ธ ๐Ÿ“ก (`sudo`) ๐Ÿ˜Œ.
///
๐Ÿ”œ โœ ๐Ÿ‘ˆ ๐ŸŽ ๐Ÿ“ `routes.toml`:
```TOML hl_lines="5 12 20"
@ -235,9 +244,12 @@ $ uvicorn main:app --root-path /api/v1
}
```
!!! tip
/// tip
๐Ÿ‘€ ๐Ÿ‘ˆ โœ‹๏ธ ๐Ÿ‘† ๐Ÿ” โšซ๏ธ `http://127.0.0.1:8000/app` โšซ๏ธ ๐ŸŽฆ `root_path` `/api/v1`, โœŠ โšช๏ธโžก๏ธ ๐ŸŽ› `--root-path`.
///
&amp; ๐Ÿ”œ ๐Ÿ“‚ ๐Ÿ“› โฎ๏ธ โ›ด Traefik, โœ… โžก ๐Ÿ”ก: <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/app</a>.
๐Ÿ‘ฅ ๐Ÿคš ๐ŸŽ ๐Ÿ“จ:
@ -279,9 +291,12 @@ $ uvicorn main:app --root-path /api/v1
## ๐ŸŒ– ๐Ÿ’ฝ
!!! warning
/// warning
๐Ÿ‘‰ ๐ŸŒ… ๐Ÿง โš™๏ธ ๐Ÿ’ผ. ๐Ÿ’ญ ๐Ÿ†“ ๐Ÿšถ โšซ๏ธ.
///
๐Ÿ”ข, **FastAPI** ๐Ÿ”œ โœ `server` ๐Ÿ—„ ๐Ÿ”— โฎ๏ธ ๐Ÿ“› `root_path`.
โœ‹๏ธ ๐Ÿ‘† ๐Ÿ’ช ๐Ÿšš ๐ŸŽ ๐ŸŽ› `servers`, ๐Ÿ–ผ ๐Ÿšฅ ๐Ÿ‘† ๐Ÿ’š *๐ŸŽ* ๐Ÿฉบ ๐ŸŽš ๐Ÿ”— โฎ๏ธ ๐Ÿ— &amp; ๐Ÿญ ๐ŸŒ.
@ -319,16 +334,22 @@ $ uvicorn main:app --root-path /api/v1
}
```
!!! tip
/// tip
๐Ÿ‘€ ๐Ÿš˜-๐Ÿ— ๐Ÿ’ฝ โฎ๏ธ `url` ๐Ÿ’ฒ `/api/v1`, โœŠ โšช๏ธโžก๏ธ `root_path`.
///
๐Ÿฉบ ๐ŸŽš <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a> โšซ๏ธ ๐Ÿ”œ ๐Ÿ‘€ ๐Ÿ’–:
<img src="/img/tutorial/behind-a-proxy/image03.png">
!!! tip
/// tip
๐Ÿฉบ ๐ŸŽš ๐Ÿ”œ ๐Ÿ”— โฎ๏ธ ๐Ÿ’ฝ ๐Ÿ‘ˆ ๐Ÿ‘† ๐Ÿ–Š.
///
### โŽ ๐Ÿง ๐Ÿ’ฝ โšช๏ธโžก๏ธ `root_path`
๐Ÿšฅ ๐Ÿ‘† ๐Ÿšซ ๐Ÿ’š **FastAPI** ๐Ÿ”Œ ๐Ÿง ๐Ÿ’ฝ โš™๏ธ `root_path`, ๐Ÿ‘† ๐Ÿ’ช โš™๏ธ ๐Ÿ”ข `root_path_in_servers=False`:

55
docs/em/docs/advanced/custom-response.md

@ -12,9 +12,12 @@
&amp; ๐Ÿšฅ ๐Ÿ‘ˆ `Response` โœ”๏ธ ๐ŸŽป ๐Ÿ“ป ๐Ÿ†Ž (`application/json`), ๐Ÿ’– ๐Ÿ’ผ โฎ๏ธ `JSONResponse` &amp; `UJSONResponse`, ๐Ÿ’ฝ ๐Ÿ‘† ๐Ÿ“จ ๐Ÿ”œ ๐Ÿ” ๐Ÿ—œ (&amp; โ›ฝ) โฎ๏ธ ๐Ÿ™† Pydantic `response_model` ๐Ÿ‘ˆ ๐Ÿ‘† ๐Ÿ“ฃ *โžก ๐Ÿ› ๏ธ ๐Ÿ‘จโ€๐ŸŽจ*.
!!! note
/// note
๐Ÿšฅ ๐Ÿ‘† โš™๏ธ ๐Ÿ“จ ๐ŸŽ“ โฎ๏ธ ๐Ÿ™…โ€โ™‚ ๐Ÿ“ป ๐Ÿ†Ž, FastAPI ๐Ÿ”œ โŒ› ๐Ÿ‘† ๐Ÿ“จ โœ”๏ธ ๐Ÿ™…โ€โ™‚ ๐ŸŽš, โšซ๏ธ ๐Ÿ”œ ๐Ÿšซ ๐Ÿ“„ ๐Ÿ“จ ๐Ÿ“ ๐Ÿšฎ ๐Ÿ— ๐Ÿ—„ ๐Ÿฉบ.
///
## โš™๏ธ `ORJSONResponse`
๐Ÿ–ผ, ๐Ÿšฅ ๐Ÿ‘† โœŠ ๐ŸŽญ, ๐Ÿ‘† ๐Ÿ’ช โŽ &amp; โš™๏ธ <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> &amp; โš’ ๐Ÿ“จ `ORJSONResponse`.
@ -31,16 +34,22 @@
{!../../../docs_src/custom_response/tutorial001b.py!}
```
!!! info
/// info
๐Ÿ”ข `response_class` ๐Ÿ”œ โš™๏ธ ๐Ÿ”ฌ "๐Ÿ“ป ๐Ÿ†Ž" ๐Ÿ“จ.
๐Ÿ‘‰ ๐Ÿ’ผ, ๐Ÿ‡บ๐Ÿ‡ธ๐Ÿ” ๐ŸŽš `Content-Type` ๐Ÿ”œ โš’ `application/json`.
&amp; โšซ๏ธ ๐Ÿ”œ ๐Ÿ“„ โœ… ๐Ÿ—„.
!!! tip
///
/// tip
`ORJSONResponse` โณ ๐Ÿ•ด ๐Ÿ’ช FastAPI, ๐Ÿšซ ๐Ÿ’ƒ.
///
## ๐Ÿ•ธ ๐Ÿ“จ
๐Ÿ“จ ๐Ÿ“จ โฎ๏ธ ๐Ÿ•ธ ๐Ÿ”— โšช๏ธโžก๏ธ **FastAPI**, โš™๏ธ `HTMLResponse`.
@ -52,13 +61,16 @@
{!../../../docs_src/custom_response/tutorial002.py!}
```
!!! info
/// info
๐Ÿ”ข `response_class` ๐Ÿ”œ โš™๏ธ ๐Ÿ”ฌ "๐Ÿ“ป ๐Ÿ†Ž" ๐Ÿ“จ.
๐Ÿ‘‰ ๐Ÿ’ผ, ๐Ÿ‡บ๐Ÿ‡ธ๐Ÿ” ๐ŸŽš `Content-Type` ๐Ÿ”œ โš’ `text/html`.
&amp; โšซ๏ธ ๐Ÿ”œ ๐Ÿ“„ โœ… ๐Ÿ—„.
///
### ๐Ÿ“จ `Response`
๐Ÿ‘€ [๐Ÿ“จ ๐Ÿ“จ ๐Ÿ”—](response-directly.md){.internal-link target=_blank}, ๐Ÿ‘† ๐Ÿ’ช ๐Ÿ” ๐Ÿ“จ ๐Ÿ”— ๐Ÿ‘† *โžก ๐Ÿ› ๏ธ*, ๐Ÿ›ฌ โšซ๏ธ.
@ -69,12 +81,18 @@
{!../../../docs_src/custom_response/tutorial003.py!}
```
!!! warning
/// warning
`Response` ๐Ÿ“จ ๐Ÿ”— ๐Ÿ‘† *โžก ๐Ÿ› ๏ธ ๐Ÿ”ข* ๐Ÿ† ๐Ÿšซ ๐Ÿ“„ ๐Ÿ—„ (๐Ÿ–ผ, `Content-Type` ๐Ÿ† ๐Ÿšซ ๐Ÿ“„) &amp; ๐Ÿ† ๐Ÿšซ โญ ๐Ÿง ๐ŸŽ“ ๐Ÿฉบ.
!!! info
///
/// info
โ†—๏ธ, โ˜‘ `Content-Type` ๐ŸŽš, ๐Ÿ‘” ๐Ÿ“Ÿ, โ™’๏ธ, ๐Ÿ”œ ๐Ÿ‘Ÿ โšช๏ธโžก๏ธ `Response` ๐ŸŽš ๐Ÿ‘† ๐Ÿ“จ.
///
### ๐Ÿ“„ ๐Ÿ—„ &amp; ๐Ÿ” `Response`
๐Ÿšฅ ๐Ÿ‘† ๐Ÿ’š ๐Ÿ” ๐Ÿ“จ โšช๏ธโžก๏ธ ๐Ÿ”˜ ๐Ÿ”ข โœ‹๏ธ ๐ŸŽ ๐Ÿ•ฐ ๐Ÿ“„ "๐Ÿ“ป ๐Ÿ†Ž" ๐Ÿ—„, ๐Ÿ‘† ๐Ÿ’ช โš™๏ธ `response_class` ๐Ÿ”ข &amp; ๐Ÿ“จ `Response` ๐ŸŽš.
@ -103,11 +121,14 @@
โœ”๏ธ ๐Ÿคฏ ๐Ÿ‘ˆ ๐Ÿ‘† ๐Ÿ’ช โš™๏ธ `Response` ๐Ÿ“จ ๐Ÿ•ณ ๐Ÿ™†, โš–๏ธ โœ ๐Ÿ›ƒ ๐ŸŽง-๐ŸŽ“.
!!! note "๐Ÿ“ก โ„น"
/// note | "๐Ÿ“ก โ„น"
๐Ÿ‘† ๐Ÿ’ช โš™๏ธ `from starlette.responses import HTMLResponse`.
**FastAPI** ๐Ÿšš ๐ŸŽ `starlette.responses` `fastapi.responses` ๐Ÿช ๐Ÿ‘†, ๐Ÿ‘ฉโ€๐Ÿ’ป. โœ‹๏ธ ๐ŸŒ… ๐Ÿ’ช ๐Ÿ“จ ๐Ÿ‘Ÿ ๐Ÿ”— โšช๏ธโžก๏ธ ๐Ÿ’ƒ.
///
### `Response`
๐Ÿ‘‘ `Response` ๐ŸŽ“, ๐ŸŒ ๐ŸŽ ๐Ÿ“จ ๐Ÿ˜– โšช๏ธโžก๏ธ โšซ๏ธ.
@ -153,16 +174,22 @@ FastAPI (๐Ÿค™ ๐Ÿ’ƒ) ๐Ÿ”œ ๐Ÿ” ๐Ÿ”Œ ๐ŸŽš-๐Ÿ“ ๐ŸŽš. โšซ๏ธ ๐Ÿ”œ ๐Ÿ”Œ ๐ŸŽš-๐Ÿ†Ž
๐ŸŽ› ๐ŸŽป ๐Ÿ“จ โš™๏ธ <a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a>.
!!! warning
/// warning
`ujson` ๐ŸŒ˜ ๐Ÿ’› ๐ŸŒ˜ ๐Ÿ ๐Ÿ—-๐Ÿ› ๏ธ โ” โšซ๏ธ ๐Ÿต ๐Ÿ“-๐Ÿ’ผ.
///
```Python hl_lines="2 7"
{!../../../docs_src/custom_response/tutorial001.py!}
```
!!! tip
/// tip
โšซ๏ธ ๐Ÿ’ช ๐Ÿ‘ˆ `ORJSONResponse` ๐Ÿ’ช โฉ ๐ŸŽ›.
///
### `RedirectResponse`
๐Ÿ“จ ๐Ÿ‡บ๐Ÿ‡ธ๐Ÿ” โŽ. โš™๏ธ 3๏ธโƒฃ0๏ธโƒฃ7๏ธโƒฃ ๐Ÿ‘” ๐Ÿ“Ÿ (๐Ÿ• โŽ) ๐Ÿ”ข.
@ -222,9 +249,12 @@ FastAPI (๐Ÿค™ ๐Ÿ’ƒ) ๐Ÿ”œ ๐Ÿ” ๐Ÿ”Œ ๐ŸŽš-๐Ÿ“ ๐ŸŽš. โšซ๏ธ ๐Ÿ”œ ๐Ÿ”Œ ๐ŸŽš-๐Ÿ†Ž
๐Ÿ”จ โšซ๏ธ ๐Ÿ‘‰ ๐ŸŒŒ, ๐Ÿ‘ฅ ๐Ÿ’ช ๐Ÿšฎ โšซ๏ธ `with` ๐Ÿซ, &amp; ๐Ÿ‘ˆ ๐ŸŒŒ, ๐Ÿšš ๐Ÿ‘ˆ โšซ๏ธ ๐Ÿ“ช โฎ๏ธ ๐Ÿ.
!!! tip
/// tip
๐Ÿ‘€ ๐Ÿ‘ˆ ๐Ÿ“ฅ ๐Ÿ‘ฅ โš™๏ธ ๐Ÿฉ `open()` ๐Ÿ‘ˆ ๐Ÿšซ ๐Ÿ•โ€๐Ÿฆบ `async` &amp; `await`, ๐Ÿ‘ฅ ๐Ÿ“ฃ โžก ๐Ÿ› ๏ธ โฎ๏ธ ๐Ÿ˜ `def`.
///
### `FileResponse`
๐Ÿ” ๐ŸŽ ๐Ÿ“ ๐Ÿ“จ.
@ -292,9 +322,12 @@ FastAPI (๐Ÿค™ ๐Ÿ’ƒ) ๐Ÿ”œ ๐Ÿ” ๐Ÿ”Œ ๐ŸŽš-๐Ÿ“ ๐ŸŽš. โšซ๏ธ ๐Ÿ”œ ๐Ÿ”Œ ๐ŸŽš-๐Ÿ†Ž
{!../../../docs_src/custom_response/tutorial010.py!}
```
!!! tip
/// tip
๐Ÿ‘† ๐Ÿ’ช ๐Ÿ” `response_class` *โžก ๐Ÿ› ๏ธ* โญ.
///
## ๐ŸŒ– ๐Ÿงพ
๐Ÿ‘† ๐Ÿ’ช ๐Ÿ“ฃ ๐Ÿ“ป ๐Ÿ†Ž &amp; ๐Ÿ“š ๐ŸŽ โ„น ๐Ÿ—„ โš™๏ธ `responses`: [๐ŸŒ– ๐Ÿ“จ ๐Ÿ—„](additional-responses.md){.internal-link target=_blank}.

5
docs/em/docs/advanced/dataclasses.md

@ -20,13 +20,16 @@ FastAPI ๐Ÿ— ๐Ÿ”› ๐Ÿ” **Pydantic**, &amp; ๐Ÿ‘ค โœ”๏ธ ๐ŸŒ ๐Ÿ‘† โ” โš™๏ธ Pyda
๐Ÿ‘‰ ๐Ÿ‘ท ๐ŸŽ ๐ŸŒŒ โฎ๏ธ Pydantic ๐Ÿท. &amp; โšซ๏ธ ๐Ÿค™ ๐Ÿ† ๐ŸŽ ๐ŸŒŒ ๐Ÿ”˜, โš™๏ธ Pydantic.
!!! info
/// info
โœ”๏ธ ๐Ÿคฏ ๐Ÿ‘ˆ ๐ŸŽป ๐Ÿ’ช ๐Ÿšซ ๐ŸŒ Pydantic ๐Ÿท ๐Ÿ’ช.
, ๐Ÿ‘† 5๏ธโƒฃ๐Ÿ“† ๐Ÿ’ช โš™๏ธ Pydantic ๐Ÿท.
โœ‹๏ธ ๐Ÿšฅ ๐Ÿ‘† โœ”๏ธ ๐Ÿ“š ๐ŸŽป ๐Ÿคฅ ๐Ÿคญ, ๐Ÿ‘‰ ๐Ÿ‘Œ ๐ŸŽฑ โš™๏ธ ๐Ÿ‘ซ ๐Ÿ‹๏ธ ๐Ÿ•ธ ๐Ÿ› ๏ธ โš™๏ธ FastAPI. ๐Ÿ‘ถ
///
## ๐ŸŽป `response_model`
๐Ÿ‘† ๐Ÿ’ช โš™๏ธ `dataclasses` `response_model` ๐Ÿ”ข:

25
docs/em/docs/advanced/events.md

@ -38,11 +38,14 @@
&amp; โคด๏ธ, โ–ถ๏ธ๏ธ โฎ๏ธ `yield`, ๐Ÿ‘ฅ ๐Ÿšš ๐Ÿท. ๐Ÿ‘‰ ๐Ÿ“Ÿ ๐Ÿ”œ ๐Ÿ› ๏ธ **โฎ๏ธ** ๐Ÿˆธ **๐Ÿ ๐Ÿšš ๐Ÿ“จ**, โ–ถ๏ธ๏ธ โญ *๐Ÿคซ*. ๐Ÿ‘‰ ๐Ÿ’ช, ๐Ÿ–ผ, ๐Ÿš€ โ„น ๐Ÿ’– ๐Ÿ’พ โš–๏ธ ๐Ÿ’ป.
!!! tip
/// tip
`shutdown` ๐Ÿ”œ ๐Ÿ”จ ๐Ÿ•โ” ๐Ÿ‘† **โ›”๏ธ** ๐Ÿˆธ.
๐ŸŽฒ ๐Ÿ‘† ๐Ÿ’ช โ–ถ๏ธ ๐Ÿ†• โฌ, โš–๏ธ ๐Ÿ‘† ๐Ÿคš ๐ŸŽก ๐Ÿƒ โšซ๏ธ. ๐Ÿคท
///
### ๐Ÿ”† ๐Ÿ”ข
๐Ÿฅ‡ ๐Ÿ‘œ ๐Ÿ‘€, ๐Ÿ‘ˆ ๐Ÿ‘ฅ โš– ๐Ÿ” ๐Ÿ”ข โฎ๏ธ `yield`. ๐Ÿ‘‰ ๐Ÿ“ถ ๐ŸŽ ๐Ÿ”— โฎ๏ธ `yield`.
@ -91,11 +94,14 @@ async with lifespan(app):
## ๐ŸŽ› ๐ŸŽ‰ (๐Ÿ˜ข)
!!! warning
/// warning
๐Ÿ‘ ๐ŸŒŒ ๐Ÿต *๐Ÿ•ด* &amp; *๐Ÿคซ* โš™๏ธ `lifespan` ๐Ÿ”ข `FastAPI` ๐Ÿ“ฑ ๐Ÿ”ฌ ๐Ÿ”›.
๐Ÿ‘† ๐Ÿ’ช ๐ŸŽฒ ๐Ÿšถ ๐Ÿ‘‰ ๐Ÿ•.
///
๐Ÿ“ค ๐ŸŽ› ๐ŸŒŒ ๐Ÿ”ฌ ๐Ÿ‘‰ โš› ๐Ÿ› ๏ธ โฎ๏ธ *๐Ÿ•ด* &amp; โฎ๏ธ *๐Ÿคซ*.
๐Ÿ‘† ๐Ÿ’ช ๐Ÿ”ฌ ๐ŸŽ‰ ๐Ÿ•โ€๐Ÿฆบ (๐Ÿ”ข) ๐Ÿ‘ˆ ๐Ÿ’ช ๐Ÿ› ๏ธ โญ ๐Ÿˆธ โ–ถ๏ธ ๐Ÿ†™, โš–๏ธ ๐Ÿ•โ” ๐Ÿˆธ ๐Ÿคซ ๐Ÿ”ฝ.
@ -126,10 +132,14 @@ async with lifespan(app):
๐Ÿ“ฅ, `shutdown` ๐ŸŽ‰ ๐Ÿ•โ€๐Ÿฆบ ๐Ÿ”ข ๐Ÿ”œ โœ โœ โธ `"Application shutdown"` ๐Ÿ“ `log.txt`.
!!! info
/// info
`open()` ๐Ÿ”ข, `mode="a"` โ›“ "๐ŸŽป",, โธ ๐Ÿ”œ ๐Ÿšฎ โฎ๏ธ โšซ๏ธโ” ๐Ÿ”› ๐Ÿ‘ˆ ๐Ÿ“, ๐Ÿต ๐Ÿ“ โฎ๏ธ ๐ŸŽš.
!!! tip
///
/// tip
๐Ÿ‘€ ๐Ÿ‘ˆ ๐Ÿ‘‰ ๐Ÿ’ผ ๐Ÿ‘ฅ โš™๏ธ ๐Ÿฉ ๐Ÿ `open()` ๐Ÿ”ข ๐Ÿ‘ˆ ๐Ÿ”— โฎ๏ธ ๐Ÿ“.
, โšซ๏ธ ๐Ÿ”Œ ๐Ÿ‘ค/๐Ÿ…พ (๐Ÿ”ข/๐Ÿ”ข), ๐Ÿ‘ˆ ๐Ÿšš "โŒ›" ๐Ÿ‘œ โœ ๐Ÿ’พ.
@ -138,9 +148,14 @@ async with lifespan(app):
, ๐Ÿ‘ฅ ๐Ÿ“ฃ ๐ŸŽ‰ ๐Ÿ•โ€๐Ÿฆบ ๐Ÿ”ข โฎ๏ธ ๐Ÿฉ `def` โ†ฉ๏ธ `async def`.
!!! info
///
/// info
๐Ÿ‘† ๐Ÿ’ช โœ ๐ŸŒ… ๐Ÿ”ƒ ๐Ÿ‘ซ ๐ŸŽ‰ ๐Ÿ•โ€๐Ÿฆบ <a href="https://www.starlette.io/events/" class="external-link" target="_blank">๐Ÿ’ƒ ๐ŸŽ‰' ๐Ÿฉบ</a>.
///
### `startup` &amp; `shutdown` ๐Ÿ‘ฏโ€โ™‚๏ธ
๐Ÿ“ค โ†• ๐Ÿคž ๐Ÿ‘ˆ โš› ๐Ÿ‘† *๐Ÿ•ด* &amp; *๐Ÿคซ* ๐Ÿ”—, ๐Ÿ‘† ๐Ÿ’ช ๐Ÿ’š โ–ถ๏ธ ๐Ÿ•ณ &amp; โคด๏ธ ๐Ÿ โšซ๏ธ, ๐Ÿ“Ž โ„น &amp; โคด๏ธ ๐Ÿš€ โšซ๏ธ, โ™’๏ธ.

29
docs/em/docs/advanced/generate-clients.md

@ -16,18 +16,22 @@
โžก๏ธ โ–ถ๏ธ โฎ๏ธ ๐Ÿ™… FastAPI ๐Ÿˆธ:
=== "๐Ÿ 3๏ธโƒฃ.6๏ธโƒฃ &amp; ๐Ÿ”›"
//// tab | ๐Ÿ 3๏ธโƒฃ.6๏ธโƒฃ &amp; ๐Ÿ”›
```Python hl_lines="9-11 14-15 18 19 23"
{!> ../../../docs_src/generate_clients/tutorial001.py!}
```
=== "๐Ÿ 3๏ธโƒฃ.9๏ธโƒฃ &amp; ๐Ÿ”›"
////
//// tab | ๐Ÿ 3๏ธโƒฃ.9๏ธโƒฃ &amp; ๐Ÿ”›
```Python hl_lines="7-9 12-13 16-17 21"
{!> ../../../docs_src/generate_clients/tutorial001_py39.py!}
```
////
๐Ÿ‘€ ๐Ÿ‘ˆ *โžก ๐Ÿ› ๏ธ* ๐Ÿ”ฌ ๐Ÿท ๐Ÿ‘ซ โš™๏ธ ๐Ÿ“จ ๐Ÿš€ &amp; ๐Ÿ“จ ๐Ÿš€, โš™๏ธ ๐Ÿท `Item` &amp; `ResponseMessage`.
### ๐Ÿ› ๏ธ ๐Ÿฉบ
@ -111,9 +115,12 @@ [email protected] generate-client /home/user/code/frontend-app
<img src="/img/tutorial/generate-clients/image03.png">
!!! tip
/// tip
๐Ÿ‘€ โœ `name` &amp; `price`, ๐Ÿ‘ˆ ๐Ÿ”ฌ FastAPI ๐Ÿˆธ, `Item` ๐Ÿท.
///
๐Ÿ‘† ๐Ÿ”œ โœ”๏ธ โธ โŒ ๐Ÿ“Š ๐Ÿ‘ˆ ๐Ÿ‘† ๐Ÿ“จ:
<img src="/img/tutorial/generate-clients/image04.png">
@ -129,18 +136,22 @@ [email protected] generate-client /home/user/code/frontend-app
๐Ÿ–ผ, ๐Ÿ‘† ๐Ÿ’ช โœ”๏ธ ๐Ÿ“„ **๐Ÿฌ** &amp; โž•1๏ธโƒฃ ๐Ÿ“„ **๐Ÿ‘ฉโ€๐Ÿ’ป**, &amp; ๐Ÿ‘ซ ๐Ÿ’ช ๐Ÿ‘ฝ ๐Ÿ”–:
=== "๐Ÿ 3๏ธโƒฃ.6๏ธโƒฃ &amp; ๐Ÿ”›"
//// tab | ๐Ÿ 3๏ธโƒฃ.6๏ธโƒฃ &amp; ๐Ÿ”›
```Python hl_lines="23 28 36"
{!> ../../../docs_src/generate_clients/tutorial002.py!}
```
=== "๐Ÿ 3๏ธโƒฃ.9๏ธโƒฃ &amp; ๐Ÿ”›"
////
//// tab | ๐Ÿ 3๏ธโƒฃ.9๏ธโƒฃ &amp; ๐Ÿ”›
```Python hl_lines="21 26 34"
{!> ../../../docs_src/generate_clients/tutorial002_py39.py!}
```
////
### ๐Ÿ— ๐Ÿ“• ๐Ÿ‘ฉโ€๐Ÿ’ป โฎ๏ธ ๐Ÿ”–
๐Ÿšฅ ๐Ÿ‘† ๐Ÿ— ๐Ÿ‘ฉโ€๐Ÿ’ป FastAPI ๐Ÿ“ฑ โš™๏ธ ๐Ÿ”–, โšซ๏ธ ๐Ÿ”œ ๐Ÿ›Ž ๐ŸŽ ๐Ÿ‘ฉโ€๐Ÿ’ป ๐Ÿ“Ÿ โš“๏ธ ๐Ÿ”› ๐Ÿ”–.
@ -186,18 +197,22 @@ FastAPI โš™๏ธ **๐Ÿ˜ ๐Ÿ†”** ๐Ÿ”  *โžก ๐Ÿ› ๏ธ*, โšซ๏ธ โš™๏ธ **๐Ÿ› ๏ธ ๐Ÿ†”**
๐Ÿ‘† ๐Ÿ’ช โคด๏ธ ๐Ÿšถโ€โ™€๏ธ ๐Ÿ‘ˆ ๐Ÿ›ƒ ๐Ÿ”ข **FastAPI** `generate_unique_id_function` ๐Ÿ”ข:
=== "๐Ÿ 3๏ธโƒฃ.6๏ธโƒฃ &amp; ๐Ÿ”›"
//// tab | ๐Ÿ 3๏ธโƒฃ.6๏ธโƒฃ &amp; ๐Ÿ”›
```Python hl_lines="8-9 12"
{!> ../../../docs_src/generate_clients/tutorial003.py!}
```
=== "๐Ÿ 3๏ธโƒฃ.9๏ธโƒฃ &amp; ๐Ÿ”›"
////
//// tab | ๐Ÿ 3๏ธโƒฃ.9๏ธโƒฃ &amp; ๐Ÿ”›
```Python hl_lines="6-7 10"
{!> ../../../docs_src/generate_clients/tutorial003_py39.py!}
```
////
### ๐Ÿ— ๐Ÿ“• ๐Ÿ‘ฉโ€๐Ÿ’ป โฎ๏ธ ๐Ÿ›ƒ ๐Ÿ› ๏ธ ๐Ÿ†”
๐Ÿ”œ ๐Ÿšฅ ๐Ÿ‘† ๐Ÿ— ๐Ÿ‘ฉโ€๐Ÿ’ป ๐Ÿ”„, ๐Ÿ‘† ๐Ÿ”œ ๐Ÿ‘€ ๐Ÿ‘ˆ โšซ๏ธ โœ”๏ธ ๐Ÿ“‰ ๐Ÿ‘ฉโ€๐Ÿ”ฌ ๐Ÿ“›:

Some files were not shown because too many files changed in this diff

Loadingโ€ฆ
Cancel
Save