🌐 Update translations for hi (add-missing) (#15925)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Yurii Motov <[email protected]>

docs/hi/docs/environment-variables.md

@@ -0,0 +1,298 @@
+# Environment Variables { #environment-variables }
+
+/// tip | टिप
+
+अगर आप पहले से जानते हैं कि "environment variables" क्या होते हैं और उनका उपयोग कैसे करना है, तो आप इसे छोड़ सकते हैं।
+
+///
+
+एक environment variable (जिसे "**env var**" भी कहा जाता है) एक variable है जो Python code के **बाहर**, **ऑपरेटिंग सिस्टम** में रहता है, और जिसे आपका Python code (या दूसरे programs भी) पढ़ सकते हैं।
+
+Environment variables application **settings** संभालने, Python की **installation** के हिस्से के रूप में, आदि में उपयोगी हो सकते हैं।
+
+## Env Vars बनाएं और उपयोग करें { #create-and-use-env-vars }
+
+आप Python की ज़रूरत के बिना, **shell (terminal)** में environment variables **बना** और उपयोग कर सकते हैं:
+
+//// tab | Linux, macOS, Windows Bash
+
+<div class="termy">
+
+```console
+// आप MY_NAME नाम का env var ऐसे बना सकते हैं
+$ export MY_NAME="Wade Wilson"
+
+// फिर आप इसे दूसरे programs के साथ उपयोग कर सकते हैं, जैसे
+$ echo "Hello $MY_NAME"
+
+Hello Wade Wilson
+```
+
+</div>
+
+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+// MY_NAME नाम का env var बनाएं
+$ $Env:MY_NAME = "Wade Wilson"
+
+// इसे दूसरे programs के साथ उपयोग करें, जैसे
+$ echo "Hello $Env:MY_NAME"
+
+Hello Wade Wilson
+```
+
+</div>
+
+////
+
+## Python में env vars पढ़ें { #read-env-vars-in-python }
+
+आप Python के **बाहर**, terminal में (या किसी भी दूसरे तरीके से) environment variables बना सकते हैं, और फिर **उन्हें Python में पढ़** सकते हैं।
+
+उदाहरण के लिए, आपके पास `main.py` नाम की file हो सकती है जिसमें:
+
+```Python hl_lines="3"
+import os
+
+name = os.getenv("MY_NAME", "World")
+print(f"Hello {name} from Python")
+```
+
+/// tip | टिप
+
+[`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) का दूसरा argument लौटाने के लिए default value है।
+
+अगर यह दिया नहीं गया है, तो default रूप से यह `None` होता है, यहाँ हम उपयोग करने के लिए default value के रूप में `"World"` देते हैं।
+
+///
+
+फिर आप उस Python program को call कर सकते हैं:
+
+//// tab | Linux, macOS, Windows Bash
+
+<div class="termy">
+
+```console
+// यहाँ हमने अभी env var set नहीं किया है
+$ python main.py
+
+// क्योंकि हमने env var set नहीं किया, हमें default value मिलती है
+
+Hello World from Python
+
+// लेकिन अगर हम पहले एक environment variable बनाते हैं
+$ export MY_NAME="Wade Wilson"
+
+// और फिर program को फिर से call करते हैं
+$ python main.py
+
+// अब यह environment variable पढ़ सकता है
+
+Hello Wade Wilson from Python
+```
+
+</div>
+
+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+// यहाँ हमने अभी env var set नहीं किया है
+$ python main.py
+
+// क्योंकि हमने env var set नहीं किया, हमें default value मिलती है
+
+Hello World from Python
+
+// लेकिन अगर हम पहले एक environment variable बनाते हैं
+$ $Env:MY_NAME = "Wade Wilson"
+
+// और फिर program को फिर से call करते हैं
+$ python main.py
+
+// अब यह environment variable पढ़ सकता है
+
+Hello Wade Wilson from Python
+```
+
+</div>
+
+////
+
+क्योंकि environment variables code के बाहर set किए जा सकते हैं, लेकिन code द्वारा पढ़े जा सकते हैं, और उन्हें बाकी files के साथ store (`git` में commit) करने की ज़रूरत नहीं होती, इसलिए configurations या **settings** के लिए उनका उपयोग करना आम है।
+
+आप किसी **specific program invocation** के लिए भी एक environment variable बना सकते हैं, जो केवल उसी program के लिए उपलब्ध होता है, और केवल उसकी अवधि तक।
+
+ऐसा करने के लिए, program से ठीक पहले, उसी line पर इसे बनाएं:
+
+<div class="termy">
+
+```console
+// इस program call के लिए line में MY_NAME नाम का env var बनाएं
+$ MY_NAME="Wade Wilson" python main.py
+
+// अब यह environment variable पढ़ सकता है
+
+Hello Wade Wilson from Python
+
+// इसके बाद env var मौजूद नहीं रहता
+$ python main.py
+
+Hello World from Python
+```
+
+</div>
+
+/// tip | टिप
+
+आप इसके बारे में [The Twelve-Factor App: Config](https://12factor.net/config) पर और पढ़ सकते हैं।
+
+///
+
+## Types और Validation { #types-and-validation }
+
+ये environment variables केवल **text strings** को ही संभाल सकते हैं, क्योंकि ये Python से बाहरी होते हैं और इन्हें दूसरे programs तथा बाकी system (और अलग-अलग ऑपरेटिंग सिस्टम, जैसे Linux, Windows, और macOS) के साथ compatible होना होता है।
+
+इसका मतलब है कि Python में environment variable से पढ़ा गया **कोई भी value** **`str` होगा**, और किसी अलग type में कोई भी conversion या कोई भी validation code में करना होगा।
+
+आप [Advanced User Guide - Settings and Environment Variables](./advanced/settings.md) में **application settings** संभालने के लिए environment variables के उपयोग के बारे में और सीखेंगे।
+
+## `PATH` Environment Variable { #path-environment-variable }
+
+**`PATH`** नाम का एक **special** environment variable होता है जिसका उपयोग ऑपरेटिंग सिस्टम (Linux, macOS, Windows) चलाने के लिए programs खोजने में करते हैं।
+
+`PATH` variable का value एक लंबी string होती है जो Linux और macOS पर colon `:` से, और Windows पर semicolon `;` से अलग की गई directories से बनी होती है।
+
+उदाहरण के लिए, `PATH` environment variable ऐसा दिख सकता है:
+
+//// tab | Linux, macOS
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
+```
+
+इसका मतलब है कि system को इन directories में programs ढूंढने चाहिए:
+
+* `/usr/local/bin`
+* `/usr/bin`
+* `/bin`
+* `/usr/sbin`
+* `/sbin`
+
+////
+
+//// tab | Windows
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
+```
+
+इसका मतलब है कि system को इन directories में programs ढूंढने चाहिए:
+
+* `C:\Program Files\Python312\Scripts`
+* `C:\Program Files\Python312`
+* `C:\Windows\System32`
+
+////
+
+जब आप terminal में कोई **command** type करते हैं, तो ऑपरेटिंग सिस्टम `PATH` environment variable में listed **उनमें से प्रत्येक directory** में program को **ढूंढता है**।
+
+उदाहरण के लिए, जब आप terminal में `python` type करते हैं, तो ऑपरेटिंग सिस्टम उस list की **पहली directory** में `python` नाम का program ढूंढता है।
+
+अगर उसे यह मिल जाता है, तो वह **इसे उपयोग** करेगा। नहीं तो वह **दूसरी directories** में ढूंढना जारी रखता है।
+
+### Python install करना और `PATH` update करना { #installing-python-and-updating-the-path }
+
+जब आप Python install करते हैं, तो आपसे पूछा जा सकता है कि क्या आप `PATH` environment variable को update करना चाहते हैं।
+
+//// tab | Linux, macOS
+
+मान लें कि आप Python install करते हैं और वह `/opt/custompython/bin` directory में जाता है।
+
+अगर आप `PATH` environment variable को update करने के लिए yes कहते हैं, तो installer `/opt/custompython/bin` को `PATH` environment variable में जोड़ देगा।
+
+यह ऐसा दिख सकता है:
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
+```
+
+इस तरह, जब आप terminal में `python` type करते हैं, तो system Python program को `/opt/custompython/bin` (आखिरी directory) में ढूंढेगा और उसी का उपयोग करेगा।
+
+////
+
+//// tab | Windows
+
+मान लें कि आप Python install करते हैं और वह `C:\opt\custompython\bin` directory में जाता है।
+
+अगर आप `PATH` environment variable को update करने के लिए yes कहते हैं, तो installer `C:\opt\custompython\bin` को `PATH` environment variable में जोड़ देगा।
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
+```
+
+इस तरह, जब आप terminal में `python` type करते हैं, तो system Python program को `C:\opt\custompython\bin` (आखिरी directory) में ढूंढेगा और उसी का उपयोग करेगा।
+
+////
+
+तो, अगर आप type करते हैं:
+
+<div class="termy">
+
+```console
+$ python
+```
+
+</div>
+
+//// tab | Linux, macOS
+
+System `/opt/custompython/bin` में `python` program को **ढूंढेगा** और उसे चलाएगा।
+
+यह लगभग ऐसा type करने के बराबर होगा:
+
+<div class="termy">
+
+```console
+$ /opt/custompython/bin/python
+```
+
+</div>
+
+////
+
+//// tab | Windows
+
+System `C:\opt\custompython\bin\python` में `python` program को **ढूंढेगा** और उसे चलाएगा।
+
+यह लगभग ऐसा type करने के बराबर होगा:
+
+<div class="termy">
+
+```console
+$ C:\opt\custompython\bin\python
+```
+
+</div>
+
+////
+
+यह जानकारी [Virtual Environments](virtual-environments.md) के बारे में सीखते समय उपयोगी होगी।
+
+## निष्कर्ष { #conclusion }
+
+इससे आपको यह basic समझ मिल जानी चाहिए कि **environment variables** क्या होते हैं और Python में उनका उपयोग कैसे करना है।
+
+आप इनके बारे में [Wikipedia for Environment Variable](https://en.wikipedia.org/wiki/Environment_variable) में भी और पढ़ सकते हैं।
+
+कई मामलों में तुरंत यह बहुत स्पष्ट नहीं होता कि environment variables कैसे उपयोगी और applicable होंगे। लेकिन जब आप developing कर रहे होते हैं, तो ये कई अलग-अलग scenarios में बार-बार सामने आते हैं, इसलिए इनके बारे में जानना अच्छा है।
+
+उदाहरण के लिए, अगले section में, [Virtual Environments](virtual-environments.md) के बारे में, आपको इस जानकारी की ज़रूरत होगी।

docs/hi/docs/help-fastapi.md

@@ -0,0 +1,87 @@
+# मदद { #help }
+
+क्या आप FastAPI की मदद करना चाहते हैं या FastAPI के बारे में मदद पाना चाहते हैं?
+
+मदद करने और मदद पाने के बहुत सरल तरीके हैं।
+
+## newsletter की सदस्यता लें { #subscribe-to-the-newsletter }
+
+आप (कभी-कभार आने वाले) [**FastAPI and friends** newsletter](newsletter.md) की सदस्यता ले सकते हैं ताकि आप इन चीज़ों से अपडेट रहें:
+
+* FastAPI और friends के बारे में खबरें 🚀
+* गाइड्स 📝
+* Features ✨
+* Breaking changes 🚨
+* टिप्स और ट्रिक्स ✅
+
+## FastAPI को ऑनलाइन फ़ॉलो करें { #follow-fastapi-online }
+
+आप **FastAPI** को कई जगहों पर ऑनलाइन फ़ॉलो कर सकते हैं:
+
+* [**X / Twitter** पर @fastapi](https://x.com/fastapi)
+* [**Bluesky** पर @fastapi.tiangolo.com](https://bsky.app/profile/fastapi.tiangolo.com)
+* [**LinkedIn** पर FastAPI](https://www.linkedin.com/company/fastapi/)
+
+## GitHub में **FastAPI** को Star करें { #star-fastapi-in-github }
+
+आप GitHub में FastAPI को "star" कर सकते हैं (ऊपर दाईं ओर star बटन पर क्लिक करके): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). ⭐️
+
+Star जोड़ने से, अन्य users इसे अधिक आसानी से ढूंढ पाएंगे और देख पाएंगे कि यह दूसरों के लिए पहले से उपयोगी रहा है।
+
+## Releases के लिए GitHub repository को Watch करें { #watch-the-github-repository-for-releases }
+
+आप GitHub में FastAPI को "watch" कर सकते हैं (ऊपर दाईं ओर "watch" बटन पर क्लिक करके): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
+
+वहाँ आप "Releases only" चुन सकते हैं।
+
+ऐसा करने पर, जब भी bug fixes और नए features के साथ **FastAPI** की कोई नई release (एक नया version) आएगी, आपको notifications (आपके email में) मिलेंगे।
+
+## लेखक को फ़ॉलो करें { #follow-the-author }
+
+आप [मुझे (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), लेखक को कुछ जगहों पर फ़ॉलो कर सकते हैं, ताकि जब मेरे पास FastAPI और friends के बारे में साझा करने के लिए खबरें हों तो आपको पता चले:
+
+* [**GitHub** पर @tiangolo](https://github.com/tiangolo).
+* [**X (Twitter)** पर @tiangolo](https://x.com/tiangolo)
+* [**Bluesky** पर @tiangolo.com](https://bsky.app/profile/tiangolo.com)
+* [**LinkedIn** पर @tiangolo](https://www.linkedin.com/in/tiangolo/).
+
+## GitHub में प्रश्नों के साथ दूसरों की मदद करें { #help-others-with-questions-in-github }
+
+आप [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered) में दूसरों के प्रश्नों में मदद करने की कोशिश कर सकते हैं।
+
+कई मामलों में आपको उन प्रश्नों का उत्तर पहले से पता हो सकता है। 🤓
+
+यदि आप बहुत से लोगों के प्रश्नों में उनकी मदद कर रहे हैं, तो आप आधिकारिक [FastAPI Expert](fastapi-people.md#fastapi-experts) बन जाएंगे। 🎉
+
+बस याद रखें, सबसे महत्वपूर्ण बात है: विनम्र रहने की कोशिश करें। 🤗
+
+### मदद कैसे करें { #how-to-help }
+
+यहाँ [मदद कैसे करें वाली गाइड](https://tiangolo.com/open-source/help/#help-others-with-questions-in-github) का पालन करें।
+
+## प्रश्न पूछें { #ask-questions }
+
+आप GitHub repository में [एक नया प्रश्न बना सकते हैं](https://github.com/fastapi/fastapi/discussions/new?category=questions), उदाहरण के लिए:
+
+* कोई **प्रश्न** पूछें या किसी **समस्या** के बारे में पूछें।
+* कोई नया **feature** सुझाएँ।
+
+## Chat से जुड़ें { #join-the-chat }
+
+👥 [Discord chat server](https://discord.gg/VQjSZaeJmf) 👥 से जुड़ें और FastAPI community में दूसरों के साथ बातचीत करें।
+
+/// tip | सुझाव
+
+प्रश्नों के लिए, उन्हें GitHub Discussions में पूछें, वहाँ आपको मदद मिलने की संभावना कहीं बेहतर है।
+
+Chat का उपयोग केवल अन्य सामान्य बातचीत के लिए करें।
+
+///
+
+### प्रश्नों के लिए Chat का उपयोग न करें { #dont-use-the-chat-for-questions }
+
+ध्यान रखें कि chats अधिक "मुक्त बातचीत" की अनुमति देते हैं, इसलिए बहुत सामान्य और उत्तर देने में अधिक कठिन प्रश्न पूछना आसान हो जाता है, इसलिए हो सकता है आपको उत्तर न मिलें।
+
+GitHub में, template आपको सही प्रश्न लिखने में मार्गदर्शन करेगा ताकि आप अधिक आसानी से अच्छा उत्तर पा सकें, या पूछने से पहले ही समस्या को स्वयं भी हल कर सकें।
+
+Chat systems में बातचीत GitHub जितनी आसानी से searchable भी नहीं होती, वे खो जाती हैं।

docs/hi/docs/learn/index.md

@@ -0,0 +1,5 @@
+# सीखें { #learn }
+
+यहाँ **FastAPI** सीखने के लिए परिचयात्मक section और ट्यूटोरियल हैं।
+
+आप इसे FastAPI सीखने का एक **book**, एक **course**, **आधिकारिक** और अनुशंसित तरीका मान सकते हैं। 😎

docs/hi/docs/tutorial/background-tasks.md

@@ -0,0 +1,86 @@
+# Background Tasks { #background-tasks }
+
+आप background tasks define कर सकते हैं जिन्हें response लौटाने के *बाद* चलाया जाए।
+
+यह उन operations के लिए उपयोगी है जिन्हें request के बाद होना होता है, लेकिन client को response पाने से पहले operation के पूरा होने का इंतज़ार करने की वास्तव में ज़रूरत नहीं होती।
+
+इसमें, उदाहरण के लिए, ये शामिल हैं:
+
+* कोई action करने के बाद भेजे गए email notifications:
+    * क्योंकि email server से connect करना और email भेजना आम तौर पर "slow" (कई seconds) होता है, आप response तुरंत लौटा सकते हैं और email notification को background में भेज सकते हैं।
+* data process करना:
+    * उदाहरण के लिए, मान लीजिए आपको एक file मिलती है जिसे किसी slow process से गुजरना है, आप "Accepted" (HTTP 202) का response लौटा सकते हैं और file को background में process कर सकते हैं।
+
+## `BackgroundTasks` का उपयोग करना { #using-backgroundtasks }
+
+सबसे पहले, `BackgroundTasks` import करें और अपनी *path operation function* में `BackgroundTasks` की type declaration के साथ एक parameter define करें:
+
+{* ../../docs_src/background_tasks/tutorial001_py310.py hl[1,13] *}
+
+**FastAPI** आपके लिए `BackgroundTasks` type का object बनाएगा और उसे उस parameter के रूप में pass करेगा।
+
+## task function बनाएँ { #create-a-task-function }
+
+background task के रूप में चलाने के लिए एक function बनाएँ।
+
+यह बस एक standard function है जो parameters receive कर सकता है।
+
+यह `async def` या normal `def` function हो सकता है, **FastAPI** जानता होगा कि इसे सही तरीके से कैसे handle करना है।
+
+इस case में, task function एक file में लिखेगा (email भेजने का simulation करते हुए)।
+
+और क्योंकि write operation `async` और `await` का उपयोग नहीं करता, हम function को normal `def` के साथ define करते हैं:
+
+{* ../../docs_src/background_tasks/tutorial001_py310.py hl[6:9] *}
+
+## background task जोड़ें { #add-the-background-task }
+
+अपनी *path operation function* के अंदर, अपनी task function को *background tasks* object में method `.add_task()` के साथ pass करें:
+
+{* ../../docs_src/background_tasks/tutorial001_py310.py hl[14] *}
+
+`.add_task()` arguments के रूप में receive करता है:
+
+* background में चलाने के लिए एक task function (`write_notification`)।
+* arguments की कोई भी sequence जो order में task function को pass की जानी चाहिए (`email`)।
+* कोई भी keyword arguments जो task function को pass किए जाने चाहिए (`message="some notification"`)।
+
+## Dependency Injection { #dependency-injection }
+
+`BackgroundTasks` का उपयोग dependency injection system के साथ भी काम करता है, आप कई levels पर `BackgroundTasks` type का parameter declare कर सकते हैं: किसी *path operation function* में, dependency (dependable) में, sub-dependency में, आदि।
+
+**FastAPI** जानता है कि हर case में क्या करना है और same object को कैसे reuse करना है, ताकि सभी background tasks merge हो जाएँ और बाद में background में run हों:
+
+
+{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
+
+
+इस example में, response भेजे जाने के *बाद* messages `log.txt` file में लिखे जाएँगे।
+
+अगर request में कोई query थी, तो उसे एक background task में log में लिखा जाएगा।
+
+और फिर *path operation function* पर generate हुआ एक और background task `email` path parameter का उपयोग करके एक message लिखेगा।
+
+## Technical Details { #technical-details }
+
+class `BackgroundTasks` सीधे [`starlette.background`](https://www.starlette.dev/background/) से आती है।
+
+इसे सीधे FastAPI में import/include किया गया है ताकि आप इसे `fastapi` से import कर सकें और गलती से `starlette.background` से alternative `BackgroundTask` (अंत में `s` के बिना) import करने से बच सकें।
+
+सिर्फ `BackgroundTasks` (और `BackgroundTask` नहीं) का उपयोग करने से, इसे *path operation function* parameter के रूप में use करना संभव होता है और **FastAPI** आपके लिए बाकी चीज़ें handle करता है, ठीक वैसे ही जैसे `Request` object को सीधे use करते समय होता है।
+
+FastAPI में अकेले `BackgroundTask` का उपयोग करना अभी भी संभव है, लेकिन आपको अपने code में object बनाना होगा और उसे शामिल करते हुए Starlette `Response` return करना होगा।
+
+आप [Background Tasks के लिए Starlette के official docs](https://www.starlette.dev/background/) में अधिक details देख सकते हैं।
+
+## सावधानी { #caveat }
+
+अगर आपको heavy background computation perform करनी है और यह ज़रूरी नहीं है कि वह same process द्वारा run हो (उदाहरण के लिए, आपको memory, variables, आदि share करने की ज़रूरत नहीं है), तो आपको [Celery](https://docs.celeryq.dev) जैसे दूसरे बड़े tools का उपयोग करने से लाभ हो सकता है।
+
+उन्हें आम तौर पर अधिक complex configurations, RabbitMQ या Redis जैसे message/job queue manager की ज़रूरत होती है, लेकिन वे आपको multiple processes में, और खासकर multiple servers में, background tasks run करने देते हैं।
+
+लेकिन अगर आपको उसी **FastAPI** app से variables और objects access करने हैं, या आपको छोटे background tasks perform करने हैं (जैसे email notification भेजना), तो आप आसानी से `BackgroundTasks` का उपयोग कर सकते हैं।
+
+## Recap { #recap }
+
+background tasks जोड़ने के लिए *path operation functions* और dependencies में parameters के साथ `BackgroundTasks` import और use करें।

docs/hi/docs/tutorial/bigger-applications.md

@@ -0,0 +1,547 @@
+# बड़े Applications - Multiple Files { #bigger-applications-multiple-files }
+
+अगर आप कोई application या web API बना रहे हैं, तो ऐसा कम ही होता है कि आप सब कुछ एक ही file में रख सकें।
+
+**FastAPI** आपके application को structure करने के लिए एक सुविधाजनक tool देता है, और साथ ही पूरी flexibility भी बनाए रखता है।
+
+/// note | नोट
+
+अगर आप Flask से आए हैं, तो यह Flask के Blueprints के बराबर होगा।
+
+///
+
+## एक उदाहरण file structure { #an-example-file-structure }
+
+मान लीजिए आपके पास ऐसा file structure है:
+
+```
+.
+├── app
+│   ├── __init__.py
+│   ├── main.py
+│   ├── dependencies.py
+│   └── routers
+│   │   ├── __init__.py
+│   │   ├── items.py
+│   │   └── users.py
+│   └── internal
+│       ├── __init__.py
+│       └── admin.py
+```
+
+/// tip | टिप
+
+कई `__init__.py` files हैं: हर directory या subdirectory में एक।
+
+यही एक file से दूसरी file में code import करने की अनुमति देता है।
+
+उदाहरण के लिए, `app/main.py` में आपके पास ऐसी line हो सकती है:
+
+```
+from app.routers import items
+```
+
+///
+
+* `app` directory में सब कुछ है। और इसमें एक खाली file `app/__init__.py` है, इसलिए यह एक "Python package" है ("Python modules" का संग्रह): `app`.
+* इसमें एक `app/main.py` file है। क्योंकि यह एक Python package (एक ऐसी directory जिसमें `__init__.py` file है) के अंदर है, यह उस package का एक "module" है: `app.main`.
+* एक `app/dependencies.py` file भी है, `app/main.py` की तरह, यह एक "module" है: `app.dependencies`.
+* एक subdirectory `app/routers/` है जिसमें एक और file `__init__.py` है, इसलिए यह एक "Python subpackage" है: `app.routers`.
+* file `app/routers/items.py` एक package, `app/routers/`, के अंदर है, इसलिए यह एक submodule है: `app.routers.items`.
+* `app/routers/users.py` के साथ भी वही है, यह एक और submodule है: `app.routers.users`.
+* एक subdirectory `app/internal/` भी है जिसमें एक और file `__init__.py` है, इसलिए यह एक और "Python subpackage" है: `app.internal`.
+* और file `app/internal/admin.py` एक और submodule है: `app.internal.admin`.
+
+<img src="/img/tutorial/bigger-applications/package.drawio.svg">
+
+वही file structure comments के साथ:
+
+```bash
+.
+├── app                  # "app" एक Python package है
+│   ├── __init__.py      # यह file "app" को "Python package" बनाती है
+│   ├── main.py          # "main" module, जैसे import app.main
+│   ├── dependencies.py  # "dependencies" module, जैसे import app.dependencies
+│   └── routers          # "routers" एक "Python subpackage" है
+│   │   ├── __init__.py  # "routers" को "Python subpackage" बनाता है
+│   │   ├── items.py     # "items" submodule, जैसे import app.routers.items
+│   │   └── users.py     # "users" submodule, जैसे import app.routers.users
+│   └── internal         # "internal" एक "Python subpackage" है
+│       ├── __init__.py  # "internal" को "Python subpackage" बनाता है
+│       └── admin.py     # "admin" submodule, जैसे import app.internal.admin
+```
+
+## `APIRouter` { #apirouter }
+
+मान लीजिए सिर्फ users को handle करने के लिए dedicated file `/app/routers/users.py` पर submodule है।
+
+आप अपने users से संबंधित *path operations* को बाकी code से अलग रखना चाहते हैं, ताकि यह व्यवस्थित रहे।
+
+लेकिन यह अभी भी उसी **FastAPI** application/web API का हिस्सा है (यह उसी "Python Package" का हिस्सा है)।
+
+आप उस module के लिए *path operations* `APIRouter` का उपयोग करके बना सकते हैं।
+
+### `APIRouter` import करें { #import-apirouter }
+
+आप इसे import करते हैं और उसी तरह एक "instance" बनाते हैं जैसे आप `FastAPI` class के साथ करते:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/users.py hl[1,3] title["app/routers/users.py"] *}
+
+### `APIRouter` के साथ *Path operations* { #path-operations-with-apirouter }
+
+और फिर आप इसका उपयोग अपने *path operations* declare करने के लिए करते हैं।
+
+इसे उसी तरह उपयोग करें जैसे आप `FastAPI` class का उपयोग करते:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
+
+आप `APIRouter` को एक "mini `FastAPI`" class की तरह सोच सकते हैं।
+
+सभी वही options समर्थित हैं।
+
+सभी वही `parameters`, `responses`, `dependencies`, `tags`, आदि।
+
+/// tip | टिप
+
+इस उदाहरण में, variable को `router` कहा गया है, लेकिन आप इसे अपनी इच्छा अनुसार कोई भी नाम दे सकते हैं।
+
+///
+
+हम इस `APIRouter` को main `FastAPI` app में शामिल करने जा रहे हैं, लेकिन पहले, dependencies और एक और `APIRouter` देखें।
+
+## Dependencies { #dependencies }
+
+हम देखते हैं कि हमें application के कई स्थानों पर उपयोग होने वाली कुछ dependencies की ज़रूरत होगी।
+
+इसलिए हम उन्हें उनके अपने `dependencies` module (`app/dependencies.py`) में रखते हैं।
+
+अब हम एक custom `X-Token` header पढ़ने के लिए एक सरल dependency का उपयोग करेंगे:
+
+{* ../../docs_src/bigger_applications/app_an_py310/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
+
+/// tip | टिप
+
+हम इस उदाहरण को सरल बनाने के लिए एक काल्पनिक header का उपयोग कर रहे हैं।
+
+लेकिन वास्तविक मामलों में आपको integrated [Security utilities](security/index.md) का उपयोग करके बेहतर परिणाम मिलेंगे।
+
+///
+
+## `APIRouter` के साथ एक और module { #another-module-with-apirouter }
+
+मान लीजिए आपके application से "items" को handle करने के लिए dedicated endpoints भी `app/routers/items.py` module में हैं।
+
+आपके पास इनके लिए *path operations* हैं:
+
+* `/items/`
+* `/items/{item_id}`
+
+यह सब `app/routers/users.py` जैसी ही structure है।
+
+लेकिन हम थोड़े अधिक smart होना चाहते हैं और code को थोड़ा simplify करना चाहते हैं।
+
+हम जानते हैं कि इस module के सभी *path operations* में वही हैं:
+
+* Path `prefix`: `/items`.
+* `tags`: (सिर्फ एक tag: `items`).
+* अतिरिक्त `responses`.
+* `dependencies`: उन सभी को वह `X-Token` dependency चाहिए जो हमने बनाई है।
+
+इसलिए, यह सब प्रत्येक *path operation* में जोड़ने के बजाय, हम इसे `APIRouter` में जोड़ सकते हैं।
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
+
+क्योंकि प्रत्येक *path operation* का path `/` से शुरू होना चाहिए, जैसे:
+
+```Python hl_lines="1"
+@router.get("/{item_id}")
+async def read_item(item_id: str):
+    ...
+```
+
+...prefix में अंत में `/` शामिल नहीं होना चाहिए।
+
+इसलिए, इस मामले में prefix `/items` है।
+
+हम `tags` की list और अतिरिक्त `responses` भी जोड़ सकते हैं जो इस router में शामिल सभी *path operations* पर लागू होंगे।
+
+और हम `dependencies` की list जोड़ सकते हैं जो router के सभी *path operations* में जोड़ी जाएगी और उन पर किए गए हर request के लिए execute/solve की जाएगी।
+
+/// tip | टिप
+
+ध्यान दें कि, [*path operation decorators* में dependencies](dependencies/dependencies-in-path-operation-decorators.md) की तरह ही, आपके *path operation function* को कोई value pass नहीं की जाएगी।
+
+///
+
+अंतिम परिणाम यह है कि item paths अब ये हैं:
+
+* `/items/`
+* `/items/{item_id}`
+
+...जैसा हमने चाहा था।
+
+* उन्हें tags की list से mark किया जाएगा जिसमें एक ही string `"items"` होगी।
+    * ये "tags" automatic interactive documentation systems (OpenAPI का उपयोग करते हुए) के लिए विशेष रूप से उपयोगी हैं।
+* उन सभी में predefined `responses` शामिल होंगे।
+* इन सभी *path operations* से पहले `dependencies` की list evaluate/execute की जाएगी।
+    * अगर आप किसी specific *path operation* में भी dependencies declare करते हैं, **तो वे भी execute होंगी**।
+    * router dependencies पहले execute होती हैं, फिर decorator में [`dependencies`](dependencies/dependencies-in-path-operation-decorators.md), और फिर normal parameter dependencies।
+    * आप [`Security` dependencies with `scopes`](../advanced/security/oauth2-scopes.md) भी जोड़ सकते हैं।
+
+/// tip | टिप
+
+`APIRouter` में `dependencies` होने का उपयोग, उदाहरण के लिए, *path operations* के पूरे group के लिए authentication require करने के लिए किया जा सकता है। भले ही dependencies उनमें से हर एक में individually न जोड़ी गई हों।
+
+///
+
+/// tip | टिप
+
+`prefix`, `tags`, `responses`, और `dependencies` parameters (कई अन्य मामलों की तरह) **FastAPI** की एक feature हैं जो आपको code duplication से बचने में मदद करती है।
+
+///
+
+### dependencies import करें { #import-the-dependencies }
+
+यह code `app.routers.items` module, file `app/routers/items.py` में रहता है।
+
+और हमें dependency function `app.dependencies` module, file `app/dependencies.py` से लेनी है।
+
+इसलिए हम dependencies के लिए `..` के साथ relative import का उपयोग करते हैं:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[3] title["app/routers/items.py"] *}
+
+#### Relative imports कैसे काम करते हैं { #how-relative-imports-work }
+
+/// tip | टिप
+
+अगर आप पूरी तरह जानते हैं कि imports कैसे काम करते हैं, तो नीचे वाले अगले section पर जाएँ।
+
+///
+
+एक single dot `.`, जैसे:
+
+```Python
+from .dependencies import get_token_header
+```
+
+का मतलब होगा:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/routers/items.py`) रहता है (directory `app/routers/`)...
+* module `dependencies` ढूँढना (`app/routers/dependencies.py` पर एक काल्पनिक file)...
+* और उससे, function `get_token_header` import करना।
+
+लेकिन वह file मौजूद नहीं है, हमारी dependencies `app/dependencies.py` पर एक file में हैं।
+
+याद रखें कि हमारी app/file structure कैसी दिखती है:
+
+<img src="/img/tutorial/bigger-applications/package.drawio.svg">
+
+---
+
+दो dots `..`, जैसे:
+
+```Python
+from ..dependencies import get_token_header
+```
+
+का मतलब है:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/routers/items.py`) रहता है (directory `app/routers/`)...
+* parent package (directory `app/`) पर जाना...
+* और वहाँ, module `dependencies` ढूँढना (file `app/dependencies.py` पर)...
+* और उससे, function `get_token_header` import करना।
+
+यह सही तरीके से काम करता है! 🎉
+
+---
+
+उसी तरह, अगर हमने तीन dots `...` का उपयोग किया होता, जैसे:
+
+```Python
+from ...dependencies import get_token_header
+```
+
+तो उसका मतलब होगा:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/routers/items.py`) रहता है (directory `app/routers/`)...
+* parent package (directory `app/`) पर जाना...
+* फिर उस package के parent पर जाना (कोई parent package नहीं है, `app` top level है 😱)...
+* और वहाँ, module `dependencies` ढूँढना (file `app/dependencies.py` पर)...
+* और उससे, function `get_token_header` import करना।
+
+यह `app/` के ऊपर किसी package को refer करेगा, जिसकी अपनी file `__init__.py` आदि होगी। लेकिन हमारे पास वह नहीं है। इसलिए, हमारे उदाहरण में इससे error आएगा। 🚨
+
+लेकिन अब आप जानते हैं कि यह कैसे काम करता है, इसलिए आप अपने apps में relative imports का उपयोग कर सकते हैं, चाहे वे कितने भी complex हों। 🤓
+
+### कुछ custom `tags`, `responses`, और `dependencies` जोड़ें { #add-some-custom-tags-responses-and-dependencies }
+
+हम प्रत्येक *path operation* में prefix `/items` या `tags=["items"]` नहीं जोड़ रहे हैं क्योंकि हमने उन्हें `APIRouter` में जोड़ दिया है।
+
+लेकिन हम अभी भी _अधिक_ `tags` जोड़ सकते हैं जो किसी specific *path operation* पर लागू होंगे, और उस *path operation* के लिए specific कुछ अतिरिक्त `responses` भी:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[30:31] title["app/routers/items.py"] *}
+
+/// tip | टिप
+
+इस आखिरी path operation में tags का combination होगा: `["items", "custom"]`।
+
+और documentation में इसके दोनों responses भी होंगे, एक `404` के लिए और एक `403` के लिए।
+
+///
+
+## मुख्य `FastAPI` { #the-main-fastapi }
+
+अब, `app/main.py` पर module देखें।
+
+यहीं आप `FastAPI` class import और use करते हैं।
+
+यह आपके application की main file होगी जो सब कुछ एक साथ जोड़ती है।
+
+और क्योंकि आपका अधिकतर logic अब अपने-अपने specific module में रहेगा, main file काफी सरल होगी।
+
+### `FastAPI` import करें { #import-fastapi }
+
+आप सामान्य रूप से `FastAPI` class import और create करते हैं।
+
+और हम [global dependencies](dependencies/global-dependencies.md) भी declare कर सकते हैं जिन्हें प्रत्येक `APIRouter` के लिए dependencies के साथ combine किया जाएगा:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[1,3,7] title["app/main.py"] *}
+
+### `APIRouter` import करें { #import-the-apirouter }
+
+अब हम उन अन्य submodules को import करते हैं जिनके पास `APIRouter`s हैं:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[4:5] title["app/main.py"] *}
+
+क्योंकि files `app/routers/users.py` और `app/routers/items.py` ऐसे submodules हैं जो उसी Python package `app` का हिस्सा हैं, हम "relative imports" का उपयोग करके उन्हें import करने के लिए single dot `.` का उपयोग कर सकते हैं।
+
+### importing कैसे काम करता है { #how-the-importing-works }
+
+section:
+
+```Python
+from .routers import items, users
+```
+
+का मतलब है:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/main.py`) रहता है (directory `app/`)...
+* subpackage `routers` ढूँढना (directory `app/routers/` पर)...
+* और उससे, submodule `items` (file `app/routers/items.py` पर) और `users` (file `app/routers/users.py` पर) import करना...
+
+module `items` में एक variable `router` (`items.router`) होगा। यह वही है जो हमने file `app/routers/items.py` में बनाया था, यह एक `APIRouter` object है।
+
+और फिर हम module `users` के लिए भी वही करते हैं।
+
+हम उन्हें इस तरह भी import कर सकते थे:
+
+```Python
+from app.routers import items, users
+```
+
+/// note | नोट
+
+पहला version एक "relative import" है:
+
+```Python
+from .routers import items, users
+```
+
+दूसरा version एक "absolute import" है:
+
+```Python
+from app.routers import items, users
+```
+
+Python Packages और Modules के बारे में अधिक जानने के लिए, [Modules के बारे में official Python documentation](https://docs.python.org/3/tutorial/modules.html) पढ़ें।
+
+///
+
+### नामों के collisions से बचें { #avoid-name-collisions }
+
+हम submodule `items` को directly import कर रहे हैं, केवल उसके variable `router` को import करने के बजाय।
+
+ऐसा इसलिए है क्योंकि हमारे पास submodule `users` में भी `router` नाम का एक और variable है।
+
+अगर हमने एक के बाद एक import किया होता, जैसे:
+
+```Python
+from .routers.items import router
+from .routers.users import router
+```
+
+तो `users` का `router`, `items` वाले को overwrite कर देता और हम उन्हें एक ही समय में use नहीं कर पाते।
+
+इसलिए, उन्हें एक ही file में दोनों को use करने में सक्षम होने के लिए, हम submodules को directly import करते हैं:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[5] title["app/main.py"] *}
+
+### `users` और `items` के लिए `APIRouter`s include करें { #include-the-apirouters-for-users-and-items }
+
+अब, submodules `users` और `items` से `router`s include करें:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[10:11] title["app/main.py"] *}
+
+/// note | नोट
+
+`users.router` file `app/routers/users.py` के अंदर मौजूद `APIRouter` को contain करता है।
+
+और `items.router` file `app/routers/items.py` के अंदर मौजूद `APIRouter` को contain करता है।
+
+///
+
+`app.include_router()` के साथ हम प्रत्येक `APIRouter` को main `FastAPI` application में जोड़ सकते हैं।
+
+यह उस router के सभी routes को उसका हिस्सा बनाकर include करेगा।
+
+/// note | तकनीकी विवरण
+
+FastAPI मूल `APIRouter` और उसके `APIRoute`s को active रखता है जब router main application में include किया जाता है।
+
+इसका मतलब है कि custom `APIRouter` और `APIRoute` subclasses router include होने के बाद भी participate कर सकते हैं।
+
+///
+
+/// tip | टिप
+
+routers include करते समय आपको performance के बारे में चिंता करने की ज़रूरत नहीं है।
+
+इसे lightweight होने और हर request में overhead जोड़ने से बचने के लिए design किया गया है।
+
+इसलिए यह performance को affect नहीं करेगा। ⚡
+
+///
+
+### custom `prefix`, `tags`, `responses`, और `dependencies` के साथ `APIRouter` include करें { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
+
+अब, कल्पना करें कि आपकी organization ने आपको `app/internal/admin.py` file दी है।
+
+इसमें कुछ admin *path operations* वाला `APIRouter` है जिसे आपकी organization कई projects के बीच share करती है।
+
+इस उदाहरण के लिए यह बहुत सरल होगा। लेकिन मान लीजिए कि क्योंकि यह organization में अन्य projects के साथ shared है, हम इसे modify नहीं कर सकते और `prefix`, `dependencies`, `tags`, आदि directly `APIRouter` में नहीं जोड़ सकते:
+
+{* ../../docs_src/bigger_applications/app_an_py310/internal/admin.py hl[3] title["app/internal/admin.py"] *}
+
+लेकिन हम फिर भी `APIRouter` include करते समय एक custom `prefix` set करना चाहते हैं ताकि इसके सभी *path operations* `/admin` से शुरू हों, हम इसे इस project के लिए पहले से मौजूद `dependencies` के साथ secure करना चाहते हैं, और हम `tags` और `responses` include करना चाहते हैं।
+
+हम original `APIRouter` को modify किए बिना यह सब declare कर सकते हैं, उन parameters को `app.include_router()` में pass करके:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[14:17] title["app/main.py"] *}
+
+इस तरह, original `APIRouter` unmodified रहेगा, इसलिए हम वही `app/internal/admin.py` file organization में अन्य projects के साथ अब भी share कर सकते हैं।
+
+परिणाम यह है कि हमारी app में, `admin` module से प्रत्येक *path operation* में होगा:
+
+* prefix `/admin`.
+* tag `admin`.
+* dependency `get_token_header`.
+* response `418`. 🍵
+
+लेकिन यह केवल हमारी app में उस `APIRouter` को affect करेगा, उसे use करने वाले किसी अन्य code को नहीं।
+
+इसलिए, उदाहरण के लिए, अन्य projects उसी `APIRouter` को किसी अलग authentication method के साथ use कर सकते हैं।
+
+### एक *path operation* include करें { #include-a-path-operation }
+
+हम सीधे `FastAPI` app में भी *path operations* जोड़ सकते हैं।
+
+यहाँ हम ऐसा करते हैं... बस यह दिखाने के लिए कि हम कर सकते हैं 🤷:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[21:23] title["app/main.py"] *}
+
+और यह `app.include_router()` के साथ जोड़े गए सभी अन्य *path operations* के साथ सही तरीके से काम करेगा।
+
+/// note | बहुत तकनीकी विवरण
+
+**नोट**: यह बहुत technical detail है जिसे आप शायद **बस skip** कर सकते हैं।
+
+---
+
+`APIRouter`s "mounted" नहीं होते, वे बाकी application से isolated नहीं होते।
+
+ऐसा इसलिए है क्योंकि हम उनके *path operations* को OpenAPI schema और user interfaces में include करना चाहते हैं।
+
+FastAPI original routers और path operations को active रखता है, और requests handle करते समय और OpenAPI generate करते समय router prefixes, dependencies, tags, responses, और अन्य metadata को combine करता है।
+
+///
+
+## `pyproject.toml` में `entrypoint` configure करें { #configure-the-entrypoint-in-pyproject-toml }
+
+क्योंकि आपका FastAPI `app` object `app/main.py` में रहता है, आप अपने `pyproject.toml` file में `entrypoint` को इस तरह configure कर सकते हैं:
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+यह इस तरह import करने के बराबर है:
+
+```python
+from app.main import app
+```
+
+इस तरह `fastapi` command जान जाएगा कि आपकी app कहाँ मिलेगी।
+
+/// Note | नोट
+
+आप command को path भी pass कर सकते हैं, जैसे:
+
+```console
+$ fastapi dev app/main.py
+```
+
+लेकिन हर बार `fastapi` command call करते समय आपको सही path pass करना याद रखना होगा।
+
+इसके अलावा, अन्य tools शायद इसे ढूँढ न पाएँ, उदाहरण के लिए [VS Code Extension](../editor-support.md) या [FastAPI Cloud](https://fastapicloud.com), इसलिए `pyproject.toml` में `entrypoint` का उपयोग करने की सलाह दी जाती है।
+
+///
+
+## automatic API docs जाँचें { #check-the-automatic-api-docs }
+
+अब, अपनी app चलाएँ:
+
+<div class="termy">
+
+```console
+$ fastapi dev
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+और docs को [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) पर खोलें।
+
+आप automatic API docs देखेंगे, जिसमें सभी submodules से paths शामिल होंगे, सही paths (और prefixes) और सही tags का उपयोग करते हुए:
+
+<img src="/img/tutorial/bigger-applications/image01.png">
+
+## अलग-अलग `prefix` के साथ उसी router को multiple times include करें { #include-the-same-router-multiple-times-with-different-prefix }
+
+आप अलग-अलग prefixes का उपयोग करके *same* router के साथ `.include_router()` को multiple times भी use कर सकते हैं।
+
+यह उपयोगी हो सकता है, उदाहरण के लिए, उसी API को अलग-अलग prefixes के तहत expose करने के लिए, जैसे `/api/v1` और `/api/latest`।
+
+यह एक advanced usage है जिसकी आपको शायद सच में ज़रूरत न हो, लेकिन अगर हो तो यह मौजूद है।
+
+## एक `APIRouter` को दूसरे में include करें { #include-an-apirouter-in-another }
+
+जिस तरह आप `FastAPI` application में `APIRouter` include कर सकते हैं, उसी तरह आप एक `APIRouter` को दूसरे `APIRouter` में include कर सकते हैं:
+
+```Python
+router.include_router(other_router)
+```
+
+आप यह `FastAPI` app में `router` include करने से पहले या बाद में कर सकते हैं। FastAPI फिर भी `other_router` से *path operations* को routing और OpenAPI में include करेगा।
+
+बाद में routers में जोड़े गए *path operations* पर भी यही लागू होता है। वे पहले वाली inclusion के माध्यम से भी visible होंगे।
+
+/// warning | तकनीकी विवरण
+
+router include करने के बाद `router.routes` को directly mutate करने से बचें। FastAPI router inclusion को live मानता है, इसलिए original router और उसके routes routing और OpenAPI generation का हिस्सा बने रहते हैं।
+
+routes और routers जोड़ने के लिए documented APIs जैसे path operation decorators और `.include_router()` का उपयोग करें।
+
+`router.routes` को एक lower-level route tree की तरह treat करें जिसमें route definitions और included routers हो सकते हैं, और इस पर final path operations की flat list की तरह rely करने से बचें।
+
+///

docs/hi/docs/tutorial/body-fields.md

@@ -0,0 +1,61 @@
+# Body - Fields { #body-fields }
+
+जिस तरह आप *path operation function* के parameters में `Query`, `Path` और `Body` के साथ अतिरिक्त validation और metadata घोषित कर सकते हैं, उसी तरह आप Pydantic के `Field` का उपयोग करके Pydantic models के अंदर validation और metadata घोषित कर सकते हैं।
+
+## `Field` import करें { #import-field }
+
+सबसे पहले, आपको इसे import करना होगा:
+
+{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[4] *}
+
+
+/// warning | चेतावनी
+
+ध्यान दें कि `Field` को सीधे `pydantic` से import किया जाता है, `fastapi` से नहीं, जैसे बाकी सभी (`Query`, `Path`, `Body`, आदि) किए जाते हैं।
+
+///
+
+## model attributes घोषित करें { #declare-model-attributes }
+
+फिर आप model attributes के साथ `Field` का उपयोग कर सकते हैं:
+
+{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[11:14] *}
+
+`Field` उसी तरह काम करता है जैसे `Query`, `Path` और `Body`, इसमें वही सभी parameters आदि होते हैं।
+
+/// note | तकनीकी विवरण
+
+वास्तव में, `Query`, `Path` और अन्य जिन्हें आप आगे देखेंगे, एक सामान्य `Param` class के subclasses के objects बनाते हैं, जो स्वयं Pydantic की `FieldInfo` class का subclass है।
+
+और Pydantic का `Field` भी `FieldInfo` का एक instance लौटाता है।
+
+`Body` भी सीधे `FieldInfo` के subclass के objects लौटाता है। और कुछ अन्य भी हैं जिन्हें आप बाद में देखेंगे, जो `Body` class के subclasses हैं।
+
+याद रखें कि जब आप `fastapi` से `Query`, `Path` और अन्य import करते हैं, तो वे वास्तव में functions होते हैं जो विशेष classes लौटाते हैं।
+
+///
+
+/// tip | सुझाव
+
+ध्यान दें कि type, default value और `Field` वाले हर model के attribute की संरचना *path operation function* के parameter जैसी ही होती है, बस `Path`, `Query` और `Body` की जगह `Field` होता है।
+
+///
+
+## अतिरिक्त जानकारी जोड़ें { #add-extra-information }
+
+आप `Field`, `Query`, `Body` आदि में अतिरिक्त जानकारी घोषित कर सकते हैं। और यह जनरेट किए गए JSON Schema में शामिल होगी।
+
+आप docs में आगे examples घोषित करना सीखते समय अतिरिक्त जानकारी जोड़ने के बारे में और जानेंगे।
+
+/// warning | चेतावनी
+
+`Field` को दिए गए अतिरिक्त keys आपके application के परिणामी OpenAPI schema में भी मौजूद होंगे।
+क्योंकि ये keys जरूरी नहीं कि OpenAPI specification का हिस्सा हों, इसलिए कुछ OpenAPI tools, उदाहरण के लिए [OpenAPI validator](https://validator.swagger.io/), आपके जनरेट किए गए schema के साथ काम नहीं कर सकते।
+
+///
+
+## Recap { #recap }
+
+आप model attributes के लिए अतिरिक्त validations और metadata घोषित करने के लिए Pydantic के `Field` का उपयोग कर सकते हैं।
+
+आप अतिरिक्त JSON Schema metadata पास करने के लिए extra keyword arguments का भी उपयोग कर सकते हैं।

docs/hi/docs/tutorial/body-multiple-params.md

@@ -0,0 +1,169 @@
+# Body - कई Parameters { #body-multiple-parameters }
+
+अब जबकि हमने देख लिया है कि `Path` और `Query` का उपयोग कैसे करना है, आइए request body declarations के और उन्नत उपयोग देखें।
+
+## `Path`, `Query` और body parameters को मिलाएँ { #mix-path-query-and-body-parameters }
+
+सबसे पहले, बेशक, आप `Path`, `Query` और request body parameter declarations को स्वतंत्र रूप से मिला सकते हैं और **FastAPI** जान जाएगा कि क्या करना है।
+
+और आप body parameters को optional भी declare कर सकते हैं, default को `None` पर सेट करके:
+
+{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
+
+/// note | नोट
+
+ध्यान दें कि, इस मामले में, body से लिया जाने वाला `item` optional है। क्योंकि इसका default value `None` है।
+
+///
+
+## कई body parameters { #multiple-body-parameters }
+
+पिछले उदाहरण में, *path operations* एक JSON body की अपेक्षा करेंगे जिसमें `Item` के attributes हों, जैसे:
+
+```JSON
+{
+    "name": "Foo",
+    "description": "The pretender",
+    "price": 42.0,
+    "tax": 3.2
+}
+```
+
+लेकिन आप कई body parameters भी declare कर सकते हैं, उदाहरण के लिए `item` और `user`:
+
+{* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
+
+
+इस मामले में, **FastAPI** ध्यान देगा कि function में एक से अधिक body parameter हैं (दो parameters हैं जो Pydantic models हैं)।
+
+तो, फिर यह parameter names को body में keys (field names) के रूप में उपयोग करेगा, और ऐसी body की अपेक्षा करेगा:
+
+```JSON
+{
+    "item": {
+        "name": "Foo",
+        "description": "The pretender",
+        "price": 42.0,
+        "tax": 3.2
+    },
+    "user": {
+        "username": "dave",
+        "full_name": "Dave Grohl"
+    }
+}
+```
+
+/// note | नोट
+
+ध्यान दें कि भले ही `item` को पहले की तरह ही declare किया गया था, अब उससे अपेक्षा की जाती है कि वह body के अंदर key `item` के साथ हो।
+
+///
+
+**FastAPI** request से automatic conversion करेगा, ताकि parameter `item` को उसकी विशिष्ट content मिले और `user` के लिए भी यही हो।
+
+यह compound data का validation करेगा, और इसे OpenAPI schema और automatic docs के लिए उसी तरह document करेगा।
+
+## body में एकल values { #singular-values-in-body }
+
+जिस तरह query और path parameters के लिए extra data define करने हेतु `Query` और `Path` हैं, **FastAPI** एक समान `Body` प्रदान करता है।
+
+उदाहरण के लिए, पिछले model को extend करते हुए, आप तय कर सकते हैं कि आप उसी body में `item` और `user` के अलावा एक और key `importance` रखना चाहते हैं।
+
+यदि आप इसे जैसे है वैसे declare करते हैं, क्योंकि यह एक single value है, **FastAPI** मान लेगा कि यह एक query parameter है।
+
+लेकिन आप **FastAPI** को `Body` का उपयोग करके इसे एक और body key के रूप में treat करने का निर्देश दे सकते हैं:
+
+{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}
+
+
+इस मामले में, **FastAPI** ऐसी body की अपेक्षा करेगा:
+
+```JSON
+{
+    "item": {
+        "name": "Foo",
+        "description": "The pretender",
+        "price": 42.0,
+        "tax": 3.2
+    },
+    "user": {
+        "username": "dave",
+        "full_name": "Dave Grohl"
+    },
+    "importance": 5
+}
+```
+
+फिर से, यह data types को convert करेगा, validate करेगा, document करेगा, आदि।
+
+## कई body params और query { #multiple-body-params-and-query }
+
+बेशक, आप जब भी ज़रूरत हो, किसी भी body parameters के अतिरिक्त, extra query parameters भी declare कर सकते हैं।
+
+क्योंकि default रूप से, single values को query parameters के रूप में interpret किया जाता है, आपको स्पष्ट रूप से `Query` जोड़ने की ज़रूरत नहीं है, आप बस ऐसा कर सकते हैं:
+
+```Python
+q: str | None = None
+```
+
+उदाहरण के लिए:
+
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
+
+
+/// note | नोट
+
+`Body` में भी वही सभी extra validation और metadata parameters हैं जो `Query`, `Path` और अन्य में हैं जिन्हें आप बाद में देखेंगे।
+
+///
+
+## एक single body parameter को embed करें { #embed-a-single-body-parameter }
+
+मान लीजिए आपके पास Pydantic model `Item` से केवल एक single `item` body parameter है।
+
+default रूप से, **FastAPI** फिर सीधे उसकी body की अपेक्षा करेगा।
+
+लेकिन यदि आप चाहते हैं कि यह key `item` के साथ JSON की अपेक्षा करे और उसके अंदर model contents हों, जैसा कि यह तब करता है जब आप extra body parameters declare करते हैं, तो आप special `Body` parameter `embed` का उपयोग कर सकते हैं:
+
+```Python
+item: Annotated[Item, Body(embed=True)]
+```
+
+जैसे कि:
+
+{* ../../docs_src/body_multiple_params/tutorial005_an_py310.py hl[17] *}
+
+
+इस मामले में **FastAPI** ऐसी body की अपेक्षा करेगा:
+
+```JSON hl_lines="2"
+{
+    "item": {
+        "name": "Foo",
+        "description": "The pretender",
+        "price": 42.0,
+        "tax": 3.2
+    }
+}
+```
+
+इसके बजाय:
+
+```JSON
+{
+    "name": "Foo",
+    "description": "The pretender",
+    "price": 42.0,
+    "tax": 3.2
+}
+```
+
+## Recap { #recap }
+
+आप अपनी *path operation function* में कई body parameters जोड़ सकते हैं, भले ही एक request में केवल एक ही body हो सकती है।
+
+लेकिन **FastAPI** इसे handle करेगा, आपको आपके function में सही data देगा, और *path operation* में सही schema को validate और document करेगा।
+
+आप single values को body के हिस्से के रूप में receive करने के लिए भी declare कर सकते हैं।
+
+और आप **FastAPI** को body को एक key में embed करने का निर्देश दे सकते हैं, भले ही केवल एक single parameter declare किया गया हो।

docs/hi/docs/tutorial/body-nested-models.md

@@ -0,0 +1,221 @@
+# Body - Nested Models { #body-nested-models }
+
+**FastAPI** के साथ, आप arbitrarily deeply nested models को define, validate, document, और use कर सकते हैं (Pydantic की बदौलत)।
+
+## List fields { #list-fields }
+
+आप किसी attribute को subtype के रूप में define कर सकते हैं। उदाहरण के लिए, एक Python `list`:
+
+{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}
+
+यह `tags` को एक list बना देगा, हालांकि यह list के elements का type declare नहीं करता।
+
+## Type parameter के साथ List fields { #list-fields-with-type-parameter }
+
+लेकिन Python में internal types, या "type parameters" के साथ lists declare करने का एक खास तरीका है:
+
+### Type parameter के साथ `list` declare करें { #declare-a-list-with-a-type-parameter }
+
+ऐसे types declare करने के लिए जिनमें type parameters (internal types) होते हैं, जैसे `list`, `dict`, `tuple`,
+internal type(s) को square brackets: `[` और `]` का उपयोग करके "type parameters" के रूप में pass करें
+
+```Python
+my_list: list[str]
+```
+
+Type declarations के लिए यह सब standard Python syntax है।
+
+Internal types वाले model attributes के लिए भी वही standard syntax उपयोग करें।
+
+तो, हमारे उदाहरण में, हम `tags` को खास तौर पर "strings की list" बना सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
+
+## Set types { #set-types }
+
+लेकिन फिर हम इस पर सोचते हैं, और समझते हैं कि tags repeat नहीं होने चाहिए, वे शायद unique strings होंगे।
+
+और Python में unique items के sets के लिए एक खास data type है, `set`।
+
+फिर हम `tags` को strings के set के रूप में declare कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}
+
+इसके साथ, भले ही आपको duplicate data वाला request मिले, वह unique items के set में convert हो जाएगा।
+
+और जब भी आप उस data को output करेंगे, भले ही source में duplicates हों, वह unique items के set के रूप में output होगा।
+
+और इसे उसी अनुसार annotate / document भी किया जाएगा।
+
+## Nested Models { #nested-models }
+
+Pydantic model के हर attribute का एक type होता है।
+
+लेकिन वह type खुद भी कोई दूसरा Pydantic model हो सकता है।
+
+इसलिए, आप खास attribute names, types और validations के साथ deeply nested JSON "objects" declare कर सकते हैं।
+
+यह सब, मनचाही गहराई तक nested हो सकता है।
+
+### Submodel define करें { #define-a-submodel }
+
+उदाहरण के लिए, हम एक `Image` model define कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
+
+### Submodel को type के रूप में उपयोग करें { #use-the-submodel-as-a-type }
+
+और फिर हम इसे किसी attribute के type के रूप में उपयोग कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}
+
+इसका मतलब होगा कि **FastAPI** कुछ इस तरह के body की अपेक्षा करेगा:
+
+```JSON
+{
+    "name": "Foo",
+    "description": "The pretender",
+    "price": 42.0,
+    "tax": 3.2,
+    "tags": ["rock", "metal", "bar"],
+    "image": {
+        "url": "http://example.com/baz.jpg",
+        "name": "The Foo live"
+    }
+}
+```
+
+फिर से, सिर्फ वह declaration करने से, **FastAPI** के साथ आपको मिलता है:
+
+* Editor support (completion, आदि), nested models के लिए भी
+* Data conversion
+* Data validation
+* Automatic documentation
+
+## Special types और validation { #special-types-and-validation }
+
+`str`, `int`, `float`, आदि जैसे सामान्य singular types के अलावा, आप अधिक complex singular types उपयोग कर सकते हैं जो `str` से inherit करते हैं।
+
+आपके पास मौजूद सभी options देखने के लिए, [Pydantic का Type Overview](https://docs.pydantic.dev/latest/concepts/types/) देखें। अगले chapter में आपको कुछ उदाहरण दिखेंगे।
+
+उदाहरण के लिए, जैसा कि `Image` model में हमारे पास एक `url` field है, हम इसे `str` के बजाय Pydantic के `HttpUrl` का instance declare कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial005_py310.py hl[2,8] *}
+
+String को valid URL होने के लिए check किया जाएगा, और JSON Schema / OpenAPI में उसी तरह document किया जाएगा।
+
+## Submodels की lists वाले attributes { #attributes-with-lists-of-submodels }
+
+आप Pydantic models को `list`, `set`, आदि के subtypes के रूप में भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
+
+यह इस तरह के JSON body की अपेक्षा करेगा (convert, validate, document, आदि):
+
+```JSON hl_lines="11"
+{
+    "name": "Foo",
+    "description": "The pretender",
+    "price": 42.0,
+    "tax": 3.2,
+    "tags": [
+        "rock",
+        "metal",
+        "bar"
+    ],
+    "images": [
+        {
+            "url": "http://example.com/baz.jpg",
+            "name": "The Foo live"
+        },
+        {
+            "url": "http://example.com/dave.jpg",
+            "name": "The Baz"
+        }
+    ]
+}
+```
+
+/// note | नोट
+
+ध्यान दें कि `images` key में अब image objects की एक list है।
+
+///
+
+## Deeply nested models { #deeply-nested-models }
+
+आप arbitrarily deeply nested models define कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial007_py310.py hl[7,12,18,21,25] *}
+
+/// note | नोट
+
+ध्यान दें कि `Offer` में `Item`s की एक list है, जिनमें आगे `Image`s की एक optional list है
+
+///
+
+## Pure lists के bodies { #bodies-of-pure-lists }
+
+अगर जिस JSON body की आप अपेक्षा करते हैं उसका top level value एक JSON `array` (एक Python `list`) है, तो आप function के parameter में type declare कर सकते हैं, बिल्कुल Pydantic models की तरह:
+
+```Python
+images: list[Image]
+```
+
+जैसे कि:
+
+{* ../../docs_src/body_nested_models/tutorial008_py310.py hl[13] *}
+
+## हर जगह editor support { #editor-support-everywhere }
+
+और आपको हर जगह editor support मिलता है।
+
+Lists के अंदर के items के लिए भी:
+
+<img src="/img/tutorial/body-nested-models/image01.png">
+
+अगर आप Pydantic models के बजाय सीधे `dict` के साथ काम कर रहे होते, तो आपको इस तरह का editor support नहीं मिल सकता था।
+
+लेकिन आपको उनकी चिंता भी करने की ज़रूरत नहीं है, आने वाले dicts अपने आप convert हो जाते हैं और आपका output भी अपने आप JSON में convert हो जाता है।
+
+## Arbitrary `dict`s के bodies { #bodies-of-arbitrary-dicts }
+
+आप body को एक `dict` के रूप में भी declare कर सकते हैं, जिसकी keys किसी type की हों और values किसी दूसरे type की।
+
+इस तरह, आपको पहले से यह जानने की ज़रूरत नहीं होती कि valid field/attribute names क्या हैं (जैसा कि Pydantic models के साथ होता)।
+
+यह तब उपयोगी होगा जब आप ऐसी keys receive करना चाहते हैं जिन्हें आप पहले से नहीं जानते।
+
+---
+
+एक और उपयोगी case वह है जब आप किसी दूसरे type (जैसे, `int`) की keys रखना चाहते हैं।
+
+यही हम यहाँ देखने जा रहे हैं।
+
+इस case में, आप कोई भी `dict` accept करेंगे, जब तक कि उसमें `float` values वाली `int` keys हों:
+
+{* ../../docs_src/body_nested_models/tutorial009_py310.py hl[7] *}
+
+/// tip | टिप
+
+ध्यान रखें कि JSON केवल `str` को keys के रूप में support करता है।
+
+लेकिन Pydantic में automatic data conversion है।
+
+इसका मतलब है कि, भले ही आपके API clients केवल strings को keys के रूप में भेज सकते हैं, जब तक उन strings में pure integers हैं, Pydantic उन्हें convert और validate कर देगा।
+
+और `weights` के रूप में आपको जो `dict` receive होगा, उसमें वास्तव में `int` keys और `float` values होंगी।
+
+///
+
+## Recap { #recap }
+
+**FastAPI** के साथ आपके पास Pydantic models द्वारा दी गई अधिकतम flexibility होती है, जबकि आपका code simple, short और elegant बना रहता है।
+
+लेकिन सभी benefits के साथ:
+
+* Editor support (हर जगह completion!)
+* Data conversion (a.k.a. parsing / serialization)
+* Data validation
+* Schema documentation
+* Automatic docs

docs/hi/docs/tutorial/body-updates.md

@@ -0,0 +1,100 @@
+# Body - अपडेट्स { #body-updates }
+
+## `PUT` के साथ बदलकर अपडेट करना { #update-replacing-with-put }
+
+किसी item को अपडेट करने के लिए आप [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) operation का उपयोग कर सकते हैं।
+
+आप input data को ऐसे data में बदलने के लिए `jsonable_encoder` का उपयोग कर सकते हैं जिसे JSON के रूप में संग्रहीत किया जा सके (जैसे NoSQL database के साथ)। उदाहरण के लिए, `datetime` को `str` में बदलना।
+
+{* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
+
+`PUT` का उपयोग ऐसा data प्राप्त करने के लिए किया जाता है जो मौजूदा data को बदल दे।
+
+### बदलने के बारे में चेतावनी { #warning-about-replacing }
+
+इसका मतलब है कि अगर आप item `bar` को `PUT` का उपयोग करके ऐसे body के साथ अपडेट करना चाहते हैं जिसमें यह हो:
+
+```Python
+{
+    "name": "Barz",
+    "price": 3,
+    "description": None,
+}
+```
+
+क्योंकि इसमें पहले से संग्रहीत attribute `"tax": 20.2` शामिल नहीं है, input model `"tax": 10.5` की default value लेगा।
+
+और data उस "नए" `tax` `10.5` के साथ सहेजा जाएगा।
+
+## `PATCH` के साथ आंशिक अपडेट्स { #partial-updates-with-patch }
+
+आप data को *आंशिक रूप से* अपडेट करने के लिए [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) operation का भी उपयोग कर सकते हैं।
+
+इसका मतलब है कि आप केवल वही data भेज सकते हैं जिसे आप अपडेट करना चाहते हैं, बाकी को वैसा ही छोड़ते हुए।
+
+/// note | नोट
+
+`PATCH`, `PUT` की तुलना में कम सामान्य रूप से उपयोग और जाना जाता है।
+
+और कई teams आंशिक अपडेट्स के लिए भी केवल `PUT` का उपयोग करती हैं।
+
+आप इन्हें जैसे चाहें वैसे उपयोग करने के लिए **स्वतंत्र** हैं, **FastAPI** कोई प्रतिबंध नहीं लगाता।
+
+लेकिन यह गाइड आपको मोटे तौर पर दिखाती है कि इन्हें कैसे उपयोग करने का इरादा है।
+
+///
+
+### Pydantic के `exclude_unset` parameter का उपयोग करना { #using-pydantics-exclude-unset-parameter }
+
+अगर आप आंशिक अपडेट्स प्राप्त करना चाहते हैं, तो Pydantic के model के `.model_dump()` में parameter `exclude_unset` का उपयोग करना बहुत उपयोगी है।
+
+जैसे `item.model_dump(exclude_unset=True)`।
+
+इससे केवल उस data के साथ एक `dict` बनेगा जो `item` model बनाते समय सेट किया गया था, default values को छोड़कर।
+
+फिर आप इसका उपयोग केवल उस data के साथ एक `dict` बनाने के लिए कर सकते हैं जो सेट किया गया था (request में भेजा गया), default values को छोड़ते हुए:
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
+
+### Pydantic के `update` parameter का उपयोग करना { #using-pydantics-update-parameter }
+
+अब, आप `.model_copy()` का उपयोग करके मौजूदा model की एक copy बना सकते हैं, और अपडेट करने के लिए data वाले `dict` के साथ `update` parameter पास कर सकते हैं।
+
+जैसे `stored_item_model.model_copy(update=update_data)`:
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
+
+### आंशिक अपडेट्स Recap { #partial-updates-recap }
+
+संक्षेप में, आंशिक अपडेट्स लागू करने के लिए आप:
+
+* (वैकल्पिक रूप से) `PUT` के बजाय `PATCH` का उपयोग करें।
+* संग्रहीत data प्राप्त करें।
+* उस data को Pydantic model में रखें।
+* input model से default values के बिना एक `dict` बनाएँ (`exclude_unset` का उपयोग करके)।
+    * इस तरह आप केवल उन values को अपडेट कर सकते हैं जिन्हें वास्तव में user ने सेट किया है, बजाय इसके कि आपके model में पहले से संग्रहीत values को default values से override कर दें।
+* संग्रहीत model की एक copy बनाएँ, और प्राप्त आंशिक अपडेट्स के साथ उसके attributes को अपडेट करें (`update` parameter का उपयोग करके)।
+* copied model को ऐसी चीज़ में बदलें जिसे आपकी DB में संग्रहीत किया जा सके (उदाहरण के लिए, `jsonable_encoder` का उपयोग करके)।
+    * यह model की `.model_dump()` method को फिर से उपयोग करने जैसा है, लेकिन यह सुनिश्चित करता है (और बदलता है) कि values ऐसे data types में हों जिन्हें JSON में बदला जा सके, उदाहरण के लिए, `datetime` को `str` में।
+* data को अपनी DB में सहेजें।
+* अपडेट किया गया model लौटाएँ।
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}
+
+/// tip | टिप
+
+आप वास्तव में इसी तकनीक का उपयोग HTTP `PUT` operation के साथ भी कर सकते हैं।
+
+लेकिन यहाँ का उदाहरण `PATCH` का उपयोग करता है क्योंकि इसे इन्हीं use cases के लिए बनाया गया था।
+
+///
+
+/// note | नोट
+
+ध्यान दें कि input model अभी भी validate किया जाता है।
+
+इसलिए, अगर आप ऐसे आंशिक अपडेट्स प्राप्त करना चाहते हैं जो सभी attributes को छोड़ सकते हैं, तो आपको ऐसा model चाहिए जिसमें सभी attributes optional के रूप में चिह्नित हों (default values या `None` के साथ)।
+
+**अपडेट्स** के लिए सभी optional values वाले models और **creation** के लिए required values वाले models में अंतर करने के लिए, आप [Extra Models](extra-models.md) में बताए गए विचारों का उपयोग कर सकते हैं।
+
+///

docs/hi/docs/tutorial/body.md

@@ -0,0 +1,166 @@
+# Request Body { #request-body }
+
+जब आपको किसी client (मान लें, एक browser) से अपनी API को data भेजना होता है, तो आप उसे **request body** के रूप में भेजते हैं।
+
+**request** body वह data है जो client आपकी API को भेजता है। **response** body वह data है जो आपकी API client को भेजती है।
+
+आपकी API को लगभग हमेशा **response** body भेजनी होती है। लेकिन clients को हर समय **request bodies** भेजने की ज़रूरत नहीं होती, कभी-कभी वे केवल एक path request करते हैं, शायद कुछ query parameters के साथ, लेकिन body नहीं भेजते।
+
+**request** body घोषित करने के लिए, आप [Pydantic](https://docs.pydantic.dev/) models का उनकी पूरी शक्ति और लाभों के साथ उपयोग करते हैं।
+
+/// note | नोट
+
+Data भेजने के लिए, आपको इनमें से किसी एक का उपयोग करना चाहिए: `POST` (सबसे आम), `PUT`, `DELETE` या `PATCH`.
+
+`GET` request के साथ body भेजने का व्यवहार specifications में undefined है, फिर भी, FastAPI इसे support करता है, केवल बहुत जटिल/चरम use cases के लिए।
+
+क्योंकि इसे discouraged किया जाता है, Swagger UI वाले interactive docs `GET` का उपयोग करते समय body के लिए documentation नहीं दिखाएँगे, और बीच में मौजूद proxies इसे support नहीं कर सकते।
+
+///
+
+## Pydantic के `BaseModel` को import करें { #import-pydantics-basemodel }
+
+सबसे पहले, आपको `pydantic` से `BaseModel` import करना होगा:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
+
+## अपना data model बनाएँ { #create-your-data-model }
+
+फिर आप अपने data model को एक class के रूप में घोषित करते हैं जो `BaseModel` से inherit करती है।
+
+सभी attributes के लिए standard Python types का उपयोग करें:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
+
+
+Query parameters घोषित करते समय की तरह, जब किसी model attribute का default value होता है, तो वह required नहीं होता। अन्यथा, वह required होता है। उसे केवल optional बनाने के लिए `None` का उपयोग करें।
+
+उदाहरण के लिए, ऊपर दिया गया यह model इस तरह का JSON "`object`" (या Python `dict`) घोषित करता है:
+
+```JSON
+{
+    "name": "Foo",
+    "description": "An optional description",
+    "price": 45.2,
+    "tax": 3.5
+}
+```
+
+...क्योंकि `description` और `tax` optional हैं (`None` के default value के साथ), यह JSON "`object`" भी valid होगा:
+
+```JSON
+{
+    "name": "Foo",
+    "price": 45.2
+}
+```
+
+## इसे एक parameter के रूप में घोषित करें { #declare-it-as-a-parameter }
+
+इसे अपनी *path operation* में जोड़ने के लिए, इसे उसी तरह घोषित करें जैसे आपने path और query parameters घोषित किए थे:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
+
+...और इसके type को आपके बनाए हुए model, `Item`, के रूप में घोषित करें।
+
+## परिणाम { #results }
+
+सिर्फ उस Python type declaration के साथ, **FastAPI** यह करेगा:
+
+* request के body को JSON के रूप में पढ़ेगा।
+* संबंधित types को convert करेगा (यदि ज़रूरत हो)।
+* data को validate करेगा।
+    * यदि data invalid है, तो यह एक अच्छा और स्पष्ट error return करेगा, जो ठीक-ठीक बताएगा कि गलत data कहाँ और क्या था।
+* आपको प्राप्त data parameter `item` में देगा।
+    * क्योंकि आपने इसे function में `Item` type का घोषित किया है, आपको इसके सभी attributes और उनके types के लिए पूरा editor support (completion, आदि) भी मिलेगा।
+* आपके model के लिए [JSON Schema](https://json-schema.org) definitions generate करेगा, यदि आपके project के लिए उचित हो तो आप उन्हें कहीं और भी उपयोग कर सकते हैं।
+* वे schemas generated OpenAPI schema का हिस्सा होंगे, और automatic documentation <abbr title="User Interfaces - उपयोगकर्ता इंटरफ़ेस">UIs</abbr> द्वारा उपयोग किए जाएँगे।
+
+## स्वचालित docs { #automatic-docs }
+
+आपके models के JSON Schemas आपके OpenAPI generated schema का हिस्सा होंगे, और interactive API docs में दिखाए जाएँगे:
+
+<img src="/img/tutorial/body/image01.png">
+
+और वे API docs में हर उस *path operation* के अंदर भी उपयोग किए जाएँगे जिसे उनकी ज़रूरत है:
+
+<img src="/img/tutorial/body/image02.png">
+
+## Editor support { #editor-support }
+
+अपने editor में, अपने function के अंदर आपको हर जगह type hints और completion मिलेंगे (यदि आपको Pydantic model के बजाय `dict` मिला होता, तो ऐसा नहीं होता):
+
+<img src="/img/tutorial/body/image03.png">
+
+आपको incorrect type operations के लिए error checks भी मिलते हैं:
+
+<img src="/img/tutorial/body/image04.png">
+
+यह संयोग से नहीं है, पूरा framework इसी design के इर्द-गिर्द बनाया गया था।
+
+और किसी भी implementation से पहले, design phase में इसे पूरी तरह test किया गया था, ताकि सुनिश्चित किया जा सके कि यह सभी editors के साथ काम करेगा।
+
+इसे support करने के लिए Pydantic में भी कुछ बदलाव किए गए थे।
+
+पिछले screenshots [Visual Studio Code](https://code.visualstudio.com) के साथ लिए गए थे।
+
+लेकिन आपको [PyCharm](https://www.jetbrains.com/pycharm/) और अधिकांश अन्य Python editors के साथ भी वही editor support मिलेगा:
+
+<img src="/img/tutorial/body/image05.png">
+
+/// tip | सुझाव
+
+यदि आप [PyCharm](https://www.jetbrains.com/pycharm/) को अपने editor के रूप में उपयोग करते हैं, तो आप [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/) का उपयोग कर सकते हैं।
+
+यह Pydantic models के लिए editor support को बेहतर बनाता है, इन चीज़ों के साथ:
+
+* auto-completion
+* type checks
+* refactoring
+* searching
+* inspections
+
+///
+
+## model का उपयोग करें { #use-the-model }
+
+Function के अंदर, आप model object के सभी attributes को सीधे access कर सकते हैं:
+
+{* ../../docs_src/body/tutorial002_py310.py *}
+
+## Request body + path parameters { #request-body-path-parameters }
+
+आप path parameters और request body को एक ही समय में घोषित कर सकते हैं।
+
+**FastAPI** पहचानेगा कि वे function parameters जो path parameters से match करते हैं, उन्हें **path से लिया जाना चाहिए**, और वे function parameters जो Pydantic models के रूप में घोषित हैं, उन्हें **request body से लिया जाना चाहिए**।
+
+{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
+
+
+## Request body + path + query parameters { #request-body-path-query-parameters }
+
+आप **body**, **path** और **query** parameters को भी एक ही समय में घोषित कर सकते हैं।
+
+**FastAPI** उनमें से प्रत्येक को पहचानेगा और data को सही जगह से लेगा।
+
+{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
+
+Function parameters को इस प्रकार पहचाना जाएगा:
+
+* यदि parameter **path** में भी घोषित है, तो उसे path parameter के रूप में उपयोग किया जाएगा।
+* यदि parameter **singular type** का है (जैसे `int`, `float`, `str`, `bool`, आदि), तो उसे **query** parameter के रूप में interpret किया जाएगा।
+* यदि parameter को **Pydantic model** के type का घोषित किया गया है, तो उसे request **body** के रूप में interpret किया जाएगा।
+
+/// note | नोट
+
+FastAPI जान जाएगा कि `q` का value required नहीं है क्योंकि उसका default value `= None` है।
+
+`str | None` का उपयोग FastAPI यह निर्धारित करने के लिए नहीं करता कि value required नहीं है, वह जान जाएगा कि यह required नहीं है क्योंकि इसका default value `= None` है।
+
+लेकिन type annotations जोड़ने से आपका editor आपको बेहतर support दे सकेगा और errors detect कर सकेगा।
+
+///
+
+## Pydantic के बिना { #without-pydantic }
+
+यदि आप Pydantic models का उपयोग नहीं करना चाहते, तो आप **Body** parameters का भी उपयोग कर सकते हैं। [Body - Multiple Parameters: Singular values in body](body-multiple-params.md#singular-values-in-body) के docs देखें।

docs/hi/docs/tutorial/cookie-param-models.md

@@ -0,0 +1,76 @@
+# Cookie Parameter Models { #cookie-parameter-models }
+
+अगर आपके पास संबंधित **cookies** का एक समूह है, तो आप उन्हें declare करने के लिए एक **Pydantic model** बना सकते हैं। 🍪
+
+यह आपको **model को फिर से उपयोग** करने की अनुमति देगा, **कई जगहों** पर, और साथ ही सभी parameters के लिए validations और metadata एक साथ declare करने की भी। 😎
+
+/// note | नोट
+
+यह FastAPI version `0.115.0` से supported है। 🤓
+
+///
+
+/// tip | सुझाव
+
+यही तकनीक `Query`, `Cookie`, और `Header` पर लागू होती है। 😎
+
+///
+
+## Pydantic Model के साथ Cookies { #cookies-with-a-pydantic-model }
+
+जिन **cookie** parameters की आपको ज़रूरत है, उन्हें एक **Pydantic model** में declare करें, और फिर parameter को `Cookie` के रूप में declare करें:
+
+{* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *}
+
+**FastAPI** request में प्राप्त **cookies** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs देखें { #check-the-docs }
+
+आप `/docs` पर docs UI में defined cookies देख सकते हैं:
+
+<div class="screenshot">
+<img src="/img/tutorial/cookie-param-models/image01.png">
+</div>
+
+/// note | नोट
+
+ध्यान रखें कि, क्योंकि **browsers cookies को** विशेष तरीकों से और पर्दे के पीछे handle करते हैं, वे **JavaScript** को आसानी से उन्हें छूने की अनुमति **नहीं** देते।
+
+अगर आप `/docs` पर **API docs UI** पर जाते हैं, तो आप अपने *path operations* के लिए cookies की **documentation** देख पाएँगे।
+
+लेकिन भले ही आप **data भरें** और "Execute" पर क्लिक करें, क्योंकि docs UI **JavaScript** के साथ काम करता है, cookies नहीं भेजे जाएँगे, और आपको एक **error** message दिखाई देगा जैसे कि आपने कोई values लिखी ही न हों।
+
+///
+
+## Extra Cookies को forbid करें { #forbid-extra-cookies }
+
+कुछ विशेष use cases में (शायद बहुत आम नहीं), आप उन cookies को **restrict** करना चाह सकते हैं जिन्हें आप प्राप्त करना चाहते हैं।
+
+आपकी API के पास अब अपनी खुद की <dfn title="यह एक मज़ाक है, बस स्पष्ट करने के लिए। इसका cookie सहमति से कोई लेना-देना नहीं है, लेकिन यह मज़ेदार है कि अब API भी बेचारे cookies को reject कर सकती है। एक cookie लीजिए। 🍪">cookie सहमति</dfn> को control करने की शक्ति है। 🤪🍪
+
+आप Pydantic के model configuration का उपयोग करके किसी भी `extra` fields को `forbid` कर सकते हैं:
+
+{* ../../docs_src/cookie_param_models/tutorial002_an_py310.py hl[10] *}
+
+अगर कोई client कुछ **extra cookies** भेजने की कोशिश करता है, तो उन्हें एक **error** response मिलेगा।
+
+बेचारे cookie banners, जो <dfn title="यह एक और मज़ाक है। मेरी बात पर ध्यान न दें। अपनी cookie के लिए कुछ coffee लीजिए। ☕">API द्वारा उसे reject किए जाने</dfn> के लिए आपकी सहमति पाने में इतनी मेहनत करते हैं। 🍪
+
+उदाहरण के लिए, अगर client `good-list-please` value के साथ एक `santa_tracker` cookie भेजने की कोशिश करता है, तो client को एक **error** response मिलेगा जो बताएगा कि `santa_tracker` <dfn title="Santa cookies की कमी को पसंद नहीं करता। 🎅 ठीक है, अब और cookie jokes नहीं।">cookie की अनुमति नहीं है</dfn>:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["cookie", "santa_tracker"],
+            "msg": "Extra inputs are not permitted",
+            "input": "good-list-please",
+        }
+    ]
+}
+```
+
+## सारांश { #summary }
+
+आप **FastAPI** में <dfn title="जाने से पहले एक आखिरी cookie लीजिए। 🍪">**cookies**</dfn> declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/cookie-params.md

@@ -0,0 +1,45 @@
+# Cookie Parameters { #cookie-parameters }
+
+आप `Cookie` parameters को उसी तरह define कर सकते हैं जैसे आप `Query` और `Path` parameters define करते हैं।
+
+## `Cookie` import करें { #import-cookie }
+
+पहले `Cookie` import करें:
+
+{* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}
+
+## `Cookie` parameters declare करें { #declare-cookie-parameters }
+
+फिर cookie parameters को `Path` और `Query` जैसी ही structure का उपयोग करके declare करें।
+
+आप default value के साथ-साथ सभी extra validation या annotation parameters भी define कर सकते हैं:
+
+{* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[9] *}
+
+/// note | तकनीकी विवरण
+
+`Cookie`, `Path` और `Query` की एक "sister" class है। यह भी उसी common `Param` class से inherit करती है।
+
+लेकिन याद रखें कि जब आप `fastapi` से `Query`, `Path`, `Cookie` और अन्य चीज़ें import करते हैं, तो वे वास्तव में ऐसे functions होते हैं जो special classes return करते हैं।
+
+///
+
+/// note | नोट
+
+Cookies declare करने के लिए, आपको `Cookie` का उपयोग करना होगा, क्योंकि अन्यथा parameters को query parameters के रूप में interpret किया जाएगा।
+
+///
+
+/// note | नोट
+
+ध्यान रखें कि, क्योंकि **browsers cookies को** विशेष तरीकों से और पर्दे के पीछे handle करते हैं, वे **JavaScript** को उन्हें आसानी से access करने की अनुमति **नहीं** देते।
+
+यदि आप `/docs` पर **API docs UI** में जाते हैं, तो आप अपनी *path operations* के लिए cookies की **documentation** देख पाएँगे।
+
+लेकिन भले ही आप **data भरें** और "Execute" पर click करें, क्योंकि docs UI **JavaScript** के साथ काम करता है, cookies भेजी नहीं जाएँगी, और आपको ऐसा **error** message दिखेगा जैसे आपने कोई values लिखी ही नहीं हों।
+
+///
+
+## Recap { #recap }
+
+`Query` और `Path` जैसे ही common pattern का उपयोग करके, `Cookie` के साथ cookies declare करें।

docs/hi/docs/tutorial/cors.md

@@ -0,0 +1,89 @@
+# CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing }
+
+[CORS या "Cross-Origin Resource Sharing"](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) उन स्थितियों को संदर्भित करता है जब browser में चल रहे frontend में JavaScript code होता है जो backend से communicate करता है, और backend frontend से अलग "origin" में होता है।
+
+## Origin { #origin }
+
+एक origin protocol (`http`, `https`), domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`), और port (`80`, `443`, `8080`) का combination होता है।
+
+तो, ये सभी अलग-अलग origins हैं:
+
+* `http://localhost`
+* `https://localhost`
+* `http://localhost:8080`
+
+भले ही वे सभी `localhost` में हों, वे अलग-अलग protocols या ports का उपयोग करते हैं, इसलिए वे अलग-अलग "origins" हैं।
+
+## Steps { #steps }
+
+तो, मान लें कि आपके browser में `http://localhost:8080` पर एक frontend चल रहा है, और उसका JavaScript `http://localhost` पर चल रहे backend से communicate करने की कोशिश कर रहा है (क्योंकि हम port specify नहीं करते, browser default port `80` मान लेगा)।
+
+फिर, browser `:80`-backend को एक HTTP `OPTIONS` request भेजेगा, और अगर backend इस अलग origin (`http://localhost:8080`) से communication को authorize करने वाले उचित headers भेजता है, तो `:8080`-browser frontend में JavaScript को अपना request `:80`-backend को भेजने देगा।
+
+इसे हासिल करने के लिए, `:80`-backend के पास "allowed origins" की एक list होनी चाहिए।
+
+इस मामले में, `:8080`-frontend के सही ढंग से काम करने के लिए list में `http://localhost:8080` शामिल होना चाहिए।
+
+## Wildcards { #wildcards }
+
+यह भी possible है कि list को `"*"` (एक "wildcard") के रूप में declare किया जाए, यह बताने के लिए कि सभी allowed हैं।
+
+लेकिन यह केवल कुछ प्रकार के communication को allow करेगा, उन सभी चीज़ों को छोड़कर जिनमें credentials शामिल हैं: Cookies, Authorization headers जैसे कि Bearer Tokens के साथ उपयोग किए जाने वाले, आदि।
+
+इसलिए, सब कुछ सही ढंग से काम करे, इसके लिए allowed origins को स्पष्ट रूप से specify करना बेहतर है।
+
+## `CORSMiddleware` का उपयोग करें { #use-corsmiddleware }
+
+आप `CORSMiddleware` का उपयोग करके इसे अपनी **FastAPI** application में configure कर सकते हैं।
+
+* `CORSMiddleware` import करें।
+* allowed origins की एक list बनाएँ (strings के रूप में)।
+* इसे अपनी **FastAPI** application में "middleware" के रूप में जोड़ें।
+
+आप यह भी specify कर सकते हैं कि आपका backend allow करता है या नहीं:
+
+* Credentials (Authorization headers, Cookies, आदि)।
+* Specific HTTP methods (`POST`, `PUT`) या wildcard `"*"` के साथ सभी methods।
+* Specific HTTP headers या wildcard `"*"` के साथ सभी headers।
+
+{* ../../docs_src/cors/tutorial001_py310.py hl[2,6:11,13:19] *}
+
+
+`CORSMiddleware` implementation द्वारा उपयोग किए जाने वाले default parameters default रूप से restrictive होते हैं, इसलिए browsers को Cross-Domain context में उनका उपयोग करने की permission देने के लिए आपको particular origins, methods, या headers को स्पष्ट रूप से enable करना होगा।
+
+निम्नलिखित arguments supported हैं:
+
+* `allow_origins` - origins की एक list जिन्हें cross-origin requests करने की permission होनी चाहिए। जैसे `['https://example.org', 'https://www.example.org']`। आप किसी भी origin को allow करने के लिए `['*']` का उपयोग कर सकते हैं।
+* `allow_origin_regex` - origins के against match करने के लिए एक regex string जिन्हें cross-origin requests करने की permission होनी चाहिए। जैसे `'https://.*\.example\.org'`।
+* `allow_methods` - HTTP methods की एक list जिन्हें cross-origin requests के लिए allowed होना चाहिए। Defaults to `['GET']`। आप सभी standard methods को allow करने के लिए `['*']` का उपयोग कर सकते हैं।
+* `allow_headers` - HTTP request headers की एक list जिन्हें cross-origin requests के लिए supported होना चाहिए। Defaults to `[]`। आप सभी headers को allow करने के लिए `['*']` का उपयोग कर सकते हैं। `Accept`, `Accept-Language`, `Content-Language` और `Content-Type` headers हमेशा [simple CORS requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests) के लिए allowed होते हैं।
+* `allow_credentials` - indicate करता है कि cookies cross-origin requests के लिए supported होनी चाहिए। Defaults to `False`.
+
+    अगर `allow_credentials` को `True` पर set किया गया है, तो `allow_origins`, `allow_methods` और `allow_headers` में से किसी को भी `['*']` पर set नहीं किया जा सकता। उन सभी को [explicitly specified](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards) होना चाहिए।
+
+* `expose_headers` - indicate करता है कि कौन से response headers browser के लिए accessible बनाए जाने चाहिए। Defaults to `[]`।
+* `max_age` - browsers के लिए CORS responses को cache करने का maximum समय seconds में set करता है। Defaults to `600`।
+
+middleware दो particular प्रकार के HTTP request का response देता है...
+
+### CORS preflight requests { #cors-preflight-requests }
+
+ये `Origin` और `Access-Control-Request-Method` headers वाले कोई भी `OPTIONS` request होते हैं।
+
+इस मामले में middleware incoming request को intercept करेगा और appropriate CORS headers के साथ respond करेगा, और informational purposes के लिए या तो `200` या `400` response देगा।
+
+### Simple requests { #simple-requests }
+
+`Origin` header वाला कोई भी request। इस मामले में middleware request को सामान्य रूप से pass through करेगा, लेकिन response पर appropriate CORS headers शामिल करेगा।
+
+## अधिक जानकारी { #more-info }
+
+<abbr title="Cross-Origin Resource Sharing - क्रॉस-ओरिजिन रिसोर्स शेयरिंग">CORS</abbr> के बारे में अधिक जानकारी के लिए, [Mozilla CORS documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) देखें।
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.middleware.cors import CORSMiddleware` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, `fastapi.middleware` में कई middlewares provide करता है। लेकिन available middlewares में से अधिकांश सीधे Starlette से आते हैं।
+
+///

docs/hi/docs/tutorial/debugging.md

@@ -0,0 +1,113 @@
+# Debugging { #debugging }
+
+आप अपने editor में debugger connect कर सकते हैं, उदाहरण के लिए Visual Studio Code या PyCharm के साथ।
+
+## `uvicorn` को call करें { #call-uvicorn }
+
+अपने FastAPI application में, `uvicorn` को सीधे import करके run करें:
+
+{* ../../docs_src/debugging/tutorial001_py310.py hl[1,15] *}
+
+### `__name__ == "__main__"` के बारे में { #about-name-main }
+
+`__name__ == "__main__"` का मुख्य उद्देश्य ऐसा कुछ code रखना है जो तब execute होता है जब आपकी file को इसके साथ call किया जाता है:
+
+<div class="termy">
+
+```console
+$ python myapp.py
+```
+
+</div>
+
+लेकिन तब call नहीं होता जब कोई दूसरी file इसे import करती है, जैसे कि:
+
+```Python
+from myapp import app
+```
+
+#### अधिक विवरण { #more-details }
+
+मान लीजिए आपकी file का नाम `myapp.py` है।
+
+अगर आप इसे इसके साथ run करते हैं:
+
+<div class="termy">
+
+```console
+$ python myapp.py
+```
+
+</div>
+
+तो आपकी file में Python द्वारा अपने आप बनाई गई internal variable `__name__` का value string `"__main__"` होगा।
+
+तो, यह section:
+
+```Python
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+run होगा।
+
+---
+
+अगर आप उस module (file) को import करते हैं तो ऐसा नहीं होगा।
+
+तो, अगर आपके पास `importer.py` नाम की कोई दूसरी file है जिसमें यह है:
+
+```Python
+from myapp import app
+
+# कुछ और code
+```
+
+उस स्थिति में, `myapp.py` के अंदर अपने आप बनाई गई variable `__name__` का value `"__main__"` नहीं होगा।
+
+तो, यह line:
+
+```Python
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+execute नहीं होगी।
+
+/// note | नोट
+
+अधिक जानकारी के लिए, [आधिकारिक Python docs](https://docs.python.org/3/library/__main__.html) देखें।
+
+///
+
+## अपने debugger के साथ अपना code run करें { #run-your-code-with-your-debugger }
+
+क्योंकि आप Uvicorn server को सीधे अपने code से run कर रहे हैं, आप अपने Python program (अपने FastAPI application) को सीधे debugger से call कर सकते हैं।
+
+---
+
+उदाहरण के लिए, Visual Studio Code में, आप यह कर सकते हैं:
+
+* "Debug" panel पर जाएँ।
+* "Add configuration..."।
+* "Python" चुनें।
+* "`Python: Current File (Integrated Terminal)`" option के साथ debugger run करें।
+
+फिर यह आपके **FastAPI** code के साथ server start करेगा, आपके breakpoints पर रुकेगा, आदि।
+
+यह कुछ ऐसा दिख सकता है:
+
+<img src="/img/tutorial/debugging/image01.png">
+
+---
+
+अगर आप PyCharm का उपयोग करते हैं, तो आप यह कर सकते हैं:
+
+* "Run" menu खोलें।
+* "Debug..." option चुनें।
+* फिर एक context menu दिखाई देता है।
+* debug करने के लिए file चुनें (इस मामले में, `main.py`)।
+
+फिर यह आपके **FastAPI** code के साथ server start करेगा, आपके breakpoints पर रुकेगा, आदि।
+
+यह कुछ ऐसा दिख सकता है:
+
+<img src="/img/tutorial/debugging/image02.png">

docs/hi/docs/tutorial/dependencies/classes-as-dependencies.md

@@ -0,0 +1,288 @@
+# Dependencies के रूप में Classes { #classes-as-dependencies }
+
+**Dependency Injection** system में और गहराई में जाने से पहले, पिछले उदाहरण को बेहतर बनाते हैं।
+
+## पिछले उदाहरण से एक `dict` { #a-dict-from-the-previous-example }
+
+पिछले उदाहरण में, हम अपनी dependency ("dependable") से एक `dict` return कर रहे थे:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}
+
+लेकिन फिर हमें *path operation function* के parameter `commons` में एक `dict` मिलता है।
+
+और हम जानते हैं कि editors `dict`s के लिए ज़्यादा support (जैसे completion) नहीं दे सकते, क्योंकि वे उनकी keys और value types नहीं जान सकते।
+
+हम इससे बेहतर कर सकते हैं...
+
+## Dependency किससे बनती है { #what-makes-a-dependency }
+
+अब तक आपने dependencies को functions के रूप में declare होते देखा है।
+
+लेकिन dependencies declare करने का यही एकमात्र तरीका नहीं है (हालाँकि शायद यह अधिक common होगा)।
+
+मुख्य बात यह है कि dependency एक "callable" होनी चाहिए।
+
+Python में "**callable**" वह कोई भी चीज़ है जिसे Python एक function की तरह "call" कर सकता है।
+
+तो, अगर आपके पास कोई object `something` है (जो शायद function _न_ हो) और आप उसे इस तरह "call" (execute) कर सकते हैं:
+
+```Python
+something()
+```
+
+या
+
+```Python
+something(some_argument, some_keyword_argument="foo")
+```
+
+तो वह एक "callable" है।
+
+## Dependencies के रूप में Classes { #classes-as-dependencies_1 }
+
+आप ध्यान दे सकते हैं कि Python class का instance बनाने के लिए भी आप वही syntax उपयोग करते हैं।
+
+उदाहरण के लिए:
+
+```Python
+class Cat:
+    def __init__(self, name: str):
+        self.name = name
+
+
+fluffy = Cat(name="Mr Fluffy")
+```
+
+इस case में, `fluffy` class `Cat` का एक instance है।
+
+और `fluffy` बनाने के लिए, आप `Cat` को "call" कर रहे हैं।
+
+इसलिए, Python class भी एक **callable** है।
+
+फिर, **FastAPI** में, आप Python class को dependency के रूप में उपयोग कर सकते हैं।
+
+FastAPI वास्तव में यह check करता है कि वह एक "callable" (function, class या कुछ और) है और उसमें parameters defined हैं।
+
+अगर आप **FastAPI** में dependency के रूप में कोई "callable" pass करते हैं, तो यह उस "callable" के parameters को analyze करेगा, और उन्हें *path operation function* के parameters की तरह ही process करेगा। इसमें sub-dependencies भी शामिल हैं।
+
+यह उन callables पर भी लागू होता है जिनमें कोई parameters नहीं होते। ठीक वैसे ही जैसे बिना parameters वाले *path operation functions* के लिए होता।
+
+फिर, हम ऊपर वाली dependency "dependable" `common_parameters` को class `CommonQueryParams` में बदल सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[11:15] *}
+
+Class का instance बनाने के लिए उपयोग की गई `__init__` method पर ध्यान दें:
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[12] *}
+
+...इसमें वही parameters हैं जो हमारे पिछले `common_parameters` में थे:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8] *}
+
+यही parameters **FastAPI** dependency को "solve" करने के लिए उपयोग करेगा।
+
+दोनों cases में, इसमें होगा:
+
+* एक optional `q` query parameter जो `str` है।
+* एक `skip` query parameter जो `int` है, जिसका default `0` है।
+* एक `limit` query parameter जो `int` है, जिसका default `100` है।
+
+दोनों cases में data converted, validated, OpenAPI schema पर documented, आदि किया जाएगा।
+
+## इसका उपयोग करें { #use-it }
+
+अब आप इस class का उपयोग करके अपनी dependency declare कर सकते हैं।
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[19] *}
+
+**FastAPI** `CommonQueryParams` class को call करता है। यह उस class का एक "instance" बनाता है और वह instance आपके function को parameter `commons` के रूप में pass किया जाएगा।
+
+## Type annotation बनाम `Depends` { #type-annotation-vs-depends }
+
+ध्यान दें कि ऊपर के code में हम `CommonQueryParams` को दो बार कैसे लिखते हैं:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends(CommonQueryParams)
+```
+
+////
+
+आखिरी `CommonQueryParams`, इसमें:
+
+```Python
+... Depends(CommonQueryParams)
+```
+
+...वही है जिसे **FastAPI** वास्तव में यह जानने के लिए उपयोग करेगा कि dependency क्या है।
+
+FastAPI इसी से declared parameters extract करेगा और वास्तव में इसी को call करेगा।
+
+---
+
+इस case में, पहला `CommonQueryParams`, इसमें:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, ...
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams ...
+```
+
+////
+
+...का **FastAPI** के लिए कोई विशेष अर्थ नहीं है। FastAPI इसे data conversion, validation, आदि के लिए उपयोग नहीं करेगा। (क्योंकि वह इसके लिए `Depends(CommonQueryParams)` का उपयोग कर रहा है)।
+
+आप वास्तव में सिर्फ यह लिख सकते हैं:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[Any, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons = Depends(CommonQueryParams)
+```
+
+////
+
+...जैसे:
+
+{* ../../docs_src/dependencies/tutorial003_an_py310.py hl[19] *}
+
+लेकिन type declare करने को प्रोत्साहित किया जाता है क्योंकि इस तरह आपका editor जान पाएगा कि parameter `commons` के रूप में क्या pass होगा, और फिर यह code completion, type checks, आदि में आपकी मदद कर सकता है:
+
+<img src="/img/tutorial/dependencies/image02.png">
+
+## Shortcut { #shortcut }
+
+लेकिन आप देखते हैं कि यहाँ कुछ code repetition हो रहा है, `CommonQueryParams` को दो बार लिखते हुए:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends(CommonQueryParams)
+```
+
+////
+
+**FastAPI** ऐसे cases के लिए एक shortcut प्रदान करता है, जहाँ dependency *specifically* एक class है जिसे **FastAPI** class का instance बनाने के लिए "call" करेगा।
+
+उन specific cases के लिए, आप यह कर सकते हैं:
+
+यह लिखने के बजाय:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends(CommonQueryParams)
+```
+
+////
+
+...आप लिखते हैं:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends()]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends()
+```
+
+////
+
+आप dependency को parameter के type के रूप में declare करते हैं, और `Depends(CommonQueryParams)` के अंदर पूरी class को *फिर से* लिखने के बजाय, आप बिना किसी parameter के `Depends()` का उपयोग करते हैं।
+
+फिर वही उदाहरण इस तरह दिखेगा:
+
+{* ../../docs_src/dependencies/tutorial004_an_py310.py hl[19] *}
+
+...और **FastAPI** जान जाएगा कि क्या करना है।
+
+/// tip | सुझाव
+
+अगर यह मददगार से ज़्यादा confusing लगता है, तो इसे अनदेखा करें, आपको इसकी *ज़रूरत* नहीं है।
+
+यह सिर्फ एक shortcut है। क्योंकि **FastAPI** आपको code repetition कम करने में मदद करने की परवाह करता है।
+
+///

docs/hi/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md

@@ -0,0 +1,69 @@
+# path operation decorators में Dependencies { #dependencies-in-path-operation-decorators }
+
+कुछ मामलों में आपको अपनी *path operation function* के अंदर किसी dependency की return value की वास्तव में ज़रूरत नहीं होती।
+
+या dependency कोई value return नहीं करती।
+
+लेकिन फिर भी आपको उसका execute/solve होना चाहिए।
+
+ऐसे मामलों के लिए, `Depends` के साथ *path operation function* parameter declare करने के बजाय, आप *path operation decorator* में `dependencies` की एक `list` जोड़ सकते हैं।
+
+## *path operation decorator* में `dependencies` जोड़ें { #add-dependencies-to-the-path-operation-decorator }
+
+*path operation decorator* एक optional argument `dependencies` प्राप्त करता है।
+
+यह `Depends()` की एक `list` होनी चाहिए:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[19] *}
+
+ये dependencies normal dependencies की तरह ही execute/solve होंगी। लेकिन उनकी value (यदि वे कोई return करती हैं) आपकी *path operation function* को pass नहीं की जाएगी।
+
+/// tip | सुझाव
+
+कुछ editors unused function parameters की जाँच करते हैं, और उन्हें errors के रूप में दिखाते हैं।
+
+*path operation decorator* में इन `dependencies` का उपयोग करके आप सुनिश्चित कर सकते हैं कि वे execute हों, साथ ही editor/tooling errors से बच सकें।
+
+यह नए developers के लिए भ्रम से बचने में भी मदद कर सकता है, जो आपके code में unused parameter देखकर सोच सकते हैं कि यह अनावश्यक है।
+
+///
+
+/// note | नोट
+
+इस example में हम बनाए गए custom headers `X-Key` और `X-Token` का उपयोग करते हैं।
+
+लेकिन वास्तविक मामलों में, security implement करते समय, आपको integrated [Security utilities (अगला अध्याय)](../security/index.md) का उपयोग करने से अधिक लाभ मिलेंगे।
+
+///
+
+## Dependencies errors और return values { #dependencies-errors-and-return-values }
+
+आप वही dependency *functions* उपयोग कर सकते हैं जिन्हें आप सामान्य रूप से उपयोग करते हैं।
+
+### Dependency requirements { #dependency-requirements }
+
+वे request requirements (जैसे headers) या अन्य sub-dependencies declare कर सकती हैं:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[8,13] *}
+
+### Exceptions raise करें { #raise-exceptions }
+
+ये dependencies normal dependencies की तरह ही exceptions `raise` कर सकती हैं:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[10,15] *}
+
+### Return values { #return-values }
+
+और वे values return कर सकती हैं या नहीं भी कर सकतीं, values का उपयोग नहीं किया जाएगा।
+
+इसलिए, आप एक normal dependency (जो value return करती है) को फिर से उपयोग कर सकते हैं जिसे आप पहले से कहीं और उपयोग करते हैं, और भले ही value का उपयोग न हो, dependency execute होगी:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[11,16] *}
+
+## *path operations* के समूह के लिए Dependencies { #dependencies-for-a-group-of-path-operations }
+
+बाद में, जब आप बड़े applications को structure करने के बारे में पढ़ेंगे ([बड़े Applications - कई Files](../../tutorial/bigger-applications.md)), संभवतः कई files के साथ, तो आप सीखेंगे कि *path operations* के समूह के लिए एक ही `dependencies` parameter कैसे declare किया जाए।
+
+## Global Dependencies { #global-dependencies }
+
+आगे हम देखेंगे कि पूरे `FastAPI` application में dependencies कैसे जोड़ी जाएँ, ताकि वे हर *path operation* पर लागू हों।

docs/hi/docs/tutorial/dependencies/dependencies-with-yield.md

@@ -0,0 +1,289 @@
+# `yield` वाली Dependencies { #dependencies-with-yield }
+
+FastAPI ऐसी dependencies को support करता है जो <dfn title='कभी-कभी इन्हें "exit code", "cleanup code", "teardown code", "closing code", "context manager exit code" आदि भी कहा जाता है।'>पूरा होने के बाद अतिरिक्त steps</dfn> करती हैं।
+
+ऐसा करने के लिए, `return` की जगह `yield` का उपयोग करें, और अतिरिक्त steps (code) उसके बाद लिखें।
+
+/// tip | सुझाव
+
+हर dependency में `yield` का उपयोग केवल एक बार करना सुनिश्चित करें।
+
+///
+
+/// note | तकनीकी विवरण
+
+कोई भी function जो इनके साथ उपयोग करने के लिए valid है:
+
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) या
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
+
+वह **FastAPI** dependency के रूप में उपयोग करने के लिए valid होगी।
+
+वास्तव में, FastAPI internally इन दोनों decorators का उपयोग करता है।
+
+///
+
+## `yield` वाली database dependency { #a-database-dependency-with-yield }
+
+उदाहरण के लिए, आप इसका उपयोग database session बनाने और पूरा होने के बाद उसे close करने के लिए कर सकते हैं।
+
+`yield` statement से पहले और उसे शामिल करते हुए केवल वही code response बनाने से पहले execute होता है:
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[2:4] *}
+
+yield किया गया value वही होता है जिसे *path operations* और अन्य dependencies में inject किया जाता है:
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[4] *}
+
+`yield` statement के बाद वाला code response के बाद execute होता है:
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[5:6] *}
+
+/// tip | सुझाव
+
+आप `async` या regular functions का उपयोग कर सकते हैं।
+
+**FastAPI** हर एक के साथ सही काम करेगा, ठीक normal dependencies की तरह।
+
+///
+
+## `yield` और `try` वाली dependency { #a-dependency-with-yield-and-try }
+
+अगर आप `yield` वाली dependency में `try` block का उपयोग करते हैं, तो dependency का उपयोग करते समय throw की गई कोई भी exception आपको मिलेगी।
+
+उदाहरण के लिए, अगर बीच में किसी point पर, किसी दूसरी dependency में या किसी *path operation* में, कुछ code ने database transaction को "rollback" किया या कोई अन्य exception बनाई, तो आपको अपनी dependency में वह exception मिलेगी।
+
+इसलिए, आप `except SomeException` के साथ dependency के अंदर उस specific exception को देख सकते हैं।
+
+इसी तरह, आप `finally` का उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि exit steps execute हों, चाहे exception आई हो या नहीं।
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[3,5] *}
+
+## `yield` वाली Sub-dependencies { #sub-dependencies-with-yield }
+
+आपके पास किसी भी size और shape की sub-dependencies और sub-dependencies के "trees" हो सकते हैं, और उनमें से कोई भी या सभी `yield` का उपयोग कर सकती हैं।
+
+**FastAPI** यह सुनिश्चित करेगा कि `yield` वाली हर dependency में "exit code" सही क्रम में run हो।
+
+उदाहरण के लिए, `dependency_c` की dependency `dependency_b` पर हो सकती है, और `dependency_b` की `dependency_a` पर:
+
+{* ../../docs_src/dependencies/tutorial008_an_py310.py hl[6,14,22] *}
+
+और वे सभी `yield` का उपयोग कर सकती हैं।
+
+इस case में `dependency_c` को अपना exit code execute करने के लिए `dependency_b` से मिला value (यहाँ `dep_b` नाम दिया गया है) अभी भी उपलब्ध चाहिए।
+
+और, बदले में, `dependency_b` को अपने exit code के लिए `dependency_a` से मिला value (यहाँ `dep_a` नाम दिया गया है) उपलब्ध चाहिए।
+
+{* ../../docs_src/dependencies/tutorial008_an_py310.py hl[18:19,26:27] *}
+
+इसी तरह, आपके पास कुछ dependencies `yield` वाली और कुछ अन्य dependencies `return` वाली हो सकती हैं, और उनमें से कुछ बाकी कुछ पर depend कर सकती हैं।
+
+और आपके पास एक single dependency हो सकती है जिसे `yield` वाली कई अन्य dependencies required हों, आदि।
+
+आप dependencies के कोई भी combinations रख सकते हैं।
+
+**FastAPI** यह सुनिश्चित करेगा कि सब कुछ सही क्रम में run हो।
+
+/// note | तकनीकी विवरण
+
+यह Python के [Context Managers](https://docs.python.org/3/library/contextlib.html) की वजह से काम करता है।
+
+**FastAPI** इसे हासिल करने के लिए internally उनका उपयोग करता है।
+
+///
+
+## `yield` और `HTTPException` वाली Dependencies { #dependencies-with-yield-and-httpexception }
+
+आपने देखा कि आप `yield` वाली dependencies का उपयोग कर सकते हैं और ऐसे `try` blocks रख सकते हैं जो कुछ code execute करने की कोशिश करते हैं और फिर `finally` के बाद कुछ exit code run करते हैं।
+
+आप raise की गई exception को catch करने और उसके साथ कुछ करने के लिए `except` का भी उपयोग कर सकते हैं।
+
+उदाहरण के लिए, आप कोई अलग exception raise कर सकते हैं, जैसे `HTTPException`।
+
+/// tip | सुझाव
+
+यह थोड़ी advanced technique है, और ज्यादातर cases में आपको वास्तव में इसकी ज़रूरत नहीं होगी, क्योंकि आप अपने application code के बाकी हिस्से के अंदर से exceptions (जिसमें `HTTPException` भी शामिल है) raise कर सकते हैं, उदाहरण के लिए, *path operation function* में।
+
+लेकिन अगर आपको इसकी ज़रूरत हो तो यह उपलब्ध है। 🤓
+
+///
+
+{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
+
+अगर आप exceptions को catch करके उसके आधार पर custom response बनाना चाहते हैं, तो [Custom Exception Handler](../handling-errors.md#install-custom-exception-handlers) बनाएँ।
+
+## `yield` और `except` वाली Dependencies { #dependencies-with-yield-and-except }
+
+अगर आप `yield` वाली dependency में `except` का उपयोग करके exception catch करते हैं और उसे फिर से raise नहीं करते (या कोई नई exception raise नहीं करते), तो FastAPI यह notice नहीं कर पाएगा कि कोई exception हुई थी, ठीक वैसे ही जैसे regular Python में होता:
+
+{* ../../docs_src/dependencies/tutorial008c_an_py310.py hl[15:16] *}
+
+इस case में, client को *HTTP 500 Internal Server Error* response दिखेगा, जैसा कि होना चाहिए, क्योंकि हम `HTTPException` या उसके जैसी कोई चीज़ raise नहीं कर रहे हैं, लेकिन server के पास **कोई logs नहीं होंगे** या error क्या था इसका कोई अन्य संकेत नहीं होगा। 😱
+
+### `yield` और `except` वाली Dependencies में हमेशा `raise` करें { #always-raise-in-dependencies-with-yield-and-except }
+
+अगर आप `yield` वाली dependency में exception catch करते हैं, तो जब तक आप कोई दूसरी `HTTPException` या similar चीज़ raise नहीं कर रहे हैं, **आपको original exception को फिर से raise करना चाहिए**।
+
+आप `raise` का उपयोग करके उसी exception को फिर से raise कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial008d_an_py310.py hl[17] *}
+
+अब client को वही *HTTP 500 Internal Server Error* response मिलेगा, लेकिन server के logs में हमारा custom `InternalError` होगा। 😎
+
+## `yield` वाली dependencies का Execution { #execution-of-dependencies-with-yield }
+
+Execution का sequence कमोबेश इस diagram जैसा है। Time ऊपर से नीचे की ओर चलता है। और हर column code के साथ interact करने या execute करने वाले parts में से एक है।
+
+```mermaid
+sequenceDiagram
+
+participant client as Client
+participant handler as Exception handler
+participant dep as Dep with yield
+participant operation as Path Operation
+participant tasks as Background tasks
+
+    Note over client,operation: Can raise exceptions, including HTTPException
+    client ->> dep: Start request
+    Note over dep: Run code up to yield
+    opt raise Exception
+        dep -->> handler: Raise Exception
+        handler -->> client: HTTP error response
+    end
+    dep ->> operation: Run dependency, e.g. DB session
+    opt raise
+        operation -->> dep: Raise Exception (e.g. HTTPException)
+        opt handle
+            dep -->> dep: Can catch exception, raise a new HTTPException, raise other exception
+        end
+        handler -->> client: HTTP error response
+    end
+
+    operation ->> client: Return response to client
+    Note over client,operation: Response is already sent, can't change it anymore
+    opt Tasks
+        operation -->> tasks: Send background tasks
+    end
+    opt Raise other exception
+        tasks -->> tasks: Handle exceptions in the background task code
+    end
+```
+
+/// note | नोट
+
+Client को केवल **एक response** भेजा जाएगा। यह error responses में से एक हो सकता है या *path operation* से आया response होगा।
+
+उन responses में से एक भेजे जाने के बाद, कोई अन्य response नहीं भेजा जा सकता।
+
+///
+
+/// tip | सुझाव
+
+अगर आप *path operation function* के code में कोई भी exception raise करते हैं, तो उसे yield वाली dependencies को pass किया जाएगा, जिसमें `HTTPException` भी शामिल है। ज्यादातर cases में आप चाहेंगे कि `yield` वाली dependency से वही exception या कोई नई exception फिर से raise करें ताकि यह सुनिश्चित हो सके कि उसे सही तरीके से handle किया गया है।
+
+///
+
+## Early exit और `scope` { #early-exit-and-scope }
+
+आम तौर पर `yield` वाली dependencies का exit code client को **response** भेजे जाने के बाद execute होता है।
+
+लेकिन अगर आपको पता है कि *path operation function* से return करने के बाद आपको dependency का उपयोग करने की ज़रूरत नहीं होगी, तो आप `Depends(scope="function")` का उपयोग करके FastAPI को बता सकते हैं कि उसे dependency को *path operation function* के return करने के बाद, लेकिन **response भेजे जाने से पहले** close करना चाहिए।
+
+{* ../../docs_src/dependencies/tutorial008e_an_py310.py hl[12,16] *}
+
+`Depends()` एक `scope` parameter receive करता है जो यह हो सकता है:
+
+* `"function"`: request handle करने वाले *path operation function* से पहले dependency शुरू करें, *path operation function* खत्म होने के बाद dependency खत्म करें, लेकिन client को response वापस भेजे जाने से **पहले**। यानी, dependency function *path operation **function*** के **around** execute होगा।
+* `"request"`: request handle करने वाले *path operation function* से पहले dependency शुरू करें (`"function"` उपयोग करने जैसा), लेकिन client को response वापस भेजे जाने के **बाद** खत्म करें। यानी, dependency function **request** और response cycle के **around** execute होगा।
+
+अगर specify नहीं किया गया है और dependency में `yield` है, तो उसका `scope` default रूप से `"request"` होगा।
+
+### Sub-dependencies के लिए `scope` { #scope-for-sub-dependencies }
+
+जब आप `scope="request"` (default) वाली dependency declare करते हैं, तो किसी भी sub-dependency का `scope` भी `"request"` होना चाहिए।
+
+लेकिन `"function"` के `scope` वाली dependency के पास `"function"` और `"request"` scope वाली dependencies हो सकती हैं।
+
+ऐसा इसलिए है क्योंकि किसी भी dependency को sub-dependencies से पहले अपना exit code run करने में सक्षम होना चाहिए, क्योंकि उसे अपने exit code के दौरान अभी भी उनका उपयोग करने की ज़रूरत हो सकती है।
+
+```mermaid
+sequenceDiagram
+
+participant client as Client
+participant dep_req as Dep scope="request"
+participant dep_func as Dep scope="function"
+participant operation as Path Operation
+
+    client ->> dep_req: Start request
+    Note over dep_req: Run code up to yield
+    dep_req ->> dep_func: Pass dependency
+    Note over dep_func: Run code up to yield
+    dep_func ->> operation: Run path operation with dependency
+    operation ->> dep_func: Return from path operation
+    Note over dep_func: Run code after yield
+    Note over dep_func: ✅ Dependency closed
+    dep_func ->> client: Send response to client
+    Note over client: Response sent
+    Note over dep_req: Run code after yield
+    Note over dep_req: ✅ Dependency closed
+```
+
+## `yield`, `HTTPException`, `except` और Background Tasks वाली Dependencies { #dependencies-with-yield-httpexception-except-and-background-tasks }
+
+`yield` वाली Dependencies समय के साथ अलग-अलग use cases cover करने और कुछ issues fix करने के लिए evolve हुई हैं।
+
+अगर आप देखना चाहते हैं कि FastAPI के अलग-अलग versions में क्या बदला है, तो आप इसके बारे में advanced guide में, [Advanced Dependencies - `yield`, `HTTPException`, `except` और Background Tasks वाली Dependencies](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks) में और पढ़ सकते हैं।
+
+## Context Managers { #context-managers }
+
+### "Context Managers" क्या हैं { #what-are-context-managers }
+
+"Context Managers" उन Python objects में से कोई भी हैं जिनका उपयोग आप `with` statement में कर सकते हैं।
+
+उदाहरण के लिए, [आप file पढ़ने के लिए `with` का उपयोग कर सकते हैं](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files):
+
+```Python
+with open("./somefile.txt") as f:
+    contents = f.read()
+    print(contents)
+```
+
+अंदर से, `open("./somefile.txt")` एक object बनाता है जिसे "Context Manager" कहा जाता है।
+
+जब `with` block खत्म होता है, तो यह file को close करना सुनिश्चित करता है, भले ही exceptions आई हों।
+
+जब आप `yield` वाली dependency बनाते हैं, तो **FastAPI** internally उसके लिए एक context manager बनाएगा, और उसे कुछ अन्य related tools के साथ combine करेगा।
+
+### `yield` वाली dependencies में context managers का उपयोग करना { #using-context-managers-in-dependencies-with-yield }
+
+/// warning | चेतावनी
+
+यह कमोबेश एक "advanced" idea है।
+
+अगर आप अभी **FastAPI** शुरू ही कर रहे हैं, तो शायद आप इसे अभी skip करना चाहेंगे।
+
+///
+
+Python में, आप [दो methods वाली class बनाकर: `__enter__()` और `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers) Context Managers बना सकते हैं।
+
+आप dependency function के अंदर `with` या `async with` statements का उपयोग करके इन्हें `yield` वाली **FastAPI** dependencies के अंदर भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial010_py310.py hl[1:9,13] *}
+
+/// tip | सुझाव
+
+Context manager बनाने का एक और तरीका है:
+
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) या
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
+
+इनका उपयोग single `yield` वाले function को decorate करने के लिए करना।
+
+**FastAPI** internally `yield` वाली dependencies के लिए यही उपयोग करता है।
+
+लेकिन आपको FastAPI dependencies के लिए decorators का उपयोग करने की ज़रूरत नहीं है (और आपको नहीं करना चाहिए)।
+
+FastAPI internally आपके लिए यह कर देगा।
+
+///

docs/hi/docs/tutorial/dependencies/global-dependencies.md

@@ -0,0 +1,16 @@
+# वैश्विक Dependencies { #global-dependencies }
+
+कुछ प्रकार के applications के लिए आप पूरे application में dependencies जोड़ना चाह सकते हैं।
+
+जिस तरह आप [*path operation decorators* में `dependencies` जोड़ सकते हैं](dependencies-in-path-operation-decorators.md), उसी तरह आप उन्हें `FastAPI` application में भी जोड़ सकते हैं।
+
+उस स्थिति में, वे application की सभी *path operations* पर लागू होंगी:
+
+{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
+
+
+और [*path operation decorators* में `dependencies` जोड़ने](dependencies-in-path-operation-decorators.md) वाले section की सभी बातें अभी भी लागू होती हैं, लेकिन इस मामले में, app की सभी *path operations* पर।
+
+## *path operations* के समूहों के लिए Dependencies { #dependencies-for-groups-of-path-operations }
+
+बाद में, जब आप बड़े applications को संरचित करने के तरीके के बारे में पढ़ेंगे ([बड़े Applications - कई Files](../../tutorial/bigger-applications.md)), संभवतः कई files के साथ, तो आप सीखेंगे कि *path operations* के एक समूह के लिए एक ही `dependencies` parameter कैसे declare किया जाए।

docs/hi/docs/tutorial/dependencies/index.md

@@ -0,0 +1,250 @@
+# Dependencies { #dependencies }
+
+**FastAPI** में एक बहुत शक्तिशाली लेकिन सहज **<dfn title="जिसे components, resources, providers, services, injectables के नाम से भी जाना जाता है">Dependency Injection</dfn>** system है।
+
+इसे उपयोग में बहुत सरल होने के लिए, और किसी भी developer के लिए दूसरे components को **FastAPI** के साथ integrate करना बहुत आसान बनाने के लिए design किया गया है।
+
+## "Dependency Injection" क्या है { #what-is-dependency-injection }
+
+**"Dependency Injection"** का मतलब programming में यह है कि आपके code (इस मामले में, आपके *path operation functions*) के पास यह declare करने का एक तरीका होता है कि उसे काम करने और उपयोग करने के लिए किन चीज़ों की ज़रूरत है: "dependencies"।
+
+और फिर, वह system (इस मामले में **FastAPI**) आपके code को वे ज़रूरी dependencies उपलब्ध कराने के लिए जो भी required है, उसका ध्यान रखेगा (dependencies को "inject" करेगा)।
+
+यह तब बहुत उपयोगी होता है जब आपको:
+
+* shared logic चाहिए (वही code logic बार-बार)।
+* database connections share करने हों।
+* security, authentication, role requirements, आदि enforce करने हों।
+* और भी कई चीज़ें...
+
+ये सब, code repetition को कम से कम रखते हुए।
+
+## पहले कदम { #first-steps }
+
+आइए एक बहुत सरल उदाहरण देखते हैं। यह इतना सरल होगा कि अभी के लिए बहुत उपयोगी नहीं है।
+
+लेकिन इस तरह हम इस बात पर focus कर सकते हैं कि **Dependency Injection** system कैसे काम करता है।
+
+### एक dependency, या "dependable" बनाएँ { #create-a-dependency-or-dependable }
+
+पहले dependency पर focus करते हैं।
+
+यह बस एक function है जो वे सभी समान parameters ले सकता है जो एक *path operation function* ले सकता है:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}
+
+बस इतना ही।
+
+**2 lines**।
+
+और इसका shape और structure वही है जो आपके सभी *path operation functions* का होता है।
+
+आप इसे "decorator" के बिना एक *path operation function* के रूप में सोच सकते हैं (`@app.get("/some-path")` के बिना)।
+
+और यह आपकी इच्छा के अनुसार कुछ भी return कर सकता है।
+
+इस मामले में, यह dependency अपेक्षा करती है:
+
+* एक optional query parameter `q` जो `str` है।
+* एक optional query parameter `skip` जो `int` है, और default रूप से `0` है।
+* एक optional query parameter `limit` जो `int` है, और default रूप से `100` है।
+
+और फिर यह बस उन values वाला एक `dict` return करता है।
+
+/// note | नोट
+
+FastAPI ने version 0.95.0 में `Annotated` के लिए support जोड़ा (और इसे recommend करना शुरू किया)।
+
+अगर आपके पास पुराना version है, तो `Annotated` का उपयोग करने की कोशिश करते समय आपको errors मिलेंगे।
+
+`Annotated` का उपयोग करने से पहले सुनिश्चित करें कि आप [FastAPI version को Upgrade](../../deployment/versions.md#upgrading-the-fastapi-versions) करके कम से कम 0.95.1 कर लें।
+
+///
+
+### `Depends` import करें { #import-depends }
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[3] *}
+
+### "dependant" में dependency declare करें { #declare-the-dependency-in-the-dependant }
+
+जिस तरह आप अपने *path operation function* parameters के साथ `Body`, `Query`, आदि का उपयोग करते हैं, उसी तरह एक नए parameter के साथ `Depends` का उपयोग करें:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[13,18] *}
+
+हालाँकि आप अपने function के parameters में `Depends` का उपयोग उसी तरह करते हैं जैसे आप `Body`, `Query`, आदि का उपयोग करते हैं, `Depends` थोड़ा अलग तरीके से काम करता है।
+
+आप `Depends` को केवल एक parameter देते हैं।
+
+यह parameter किसी function जैसा होना चाहिए।
+
+आप इसे सीधे **call नहीं करते** (अंत में parentheses नहीं जोड़ते), आप बस इसे `Depends()` को एक parameter के रूप में pass करते हैं।
+
+और वह function उसी तरह parameters लेता है जैसे *path operation functions* लेते हैं।
+
+/// tip | सुझाव
+
+अगले chapter में आप देखेंगे कि functions के अलावा कौन सी दूसरी "चीज़ें" dependencies के रूप में उपयोग की जा सकती हैं।
+
+///
+
+जब भी कोई नया request आता है, **FastAPI** इन बातों का ध्यान रखेगा:
+
+* आपकी dependency ("dependable") function को सही parameters के साथ call करना।
+* आपके function से result लेना।
+* उस result को आपके *path operation function* के parameter को assign करना।
+
+```mermaid
+graph TB
+
+common_parameters(["common_parameters"])
+read_items["/items/"]
+read_users["/users/"]
+
+common_parameters --> read_items
+common_parameters --> read_users
+```
+
+इस तरह आप shared code एक बार लिखते हैं और **FastAPI** आपके *path operations* के लिए उसे call करने का ध्यान रखता है।
+
+/// tip | सुझाव
+
+ध्यान दें कि आपको कोई special class बनाकर उसे **FastAPI** को "register" करने के लिए कहीं pass करने या ऐसा कुछ करने की ज़रूरत नहीं है।
+
+आप बस इसे `Depends` को pass करते हैं और **FastAPI** जानता है कि बाकी कैसे करना है।
+
+///
+
+## `Annotated` dependencies share करें { #share-annotated-dependencies }
+
+ऊपर के उदाहरणों में, आप देखते हैं कि **code duplication** का थोड़ा सा हिस्सा है।
+
+जब आपको `common_parameters()` dependency का उपयोग करना हो, तो आपको type annotation और `Depends()` के साथ पूरा parameter लिखना पड़ता है:
+
+```Python
+commons: Annotated[dict, Depends(common_parameters)]
+```
+
+लेकिन क्योंकि हम `Annotated` का उपयोग कर रहे हैं, हम उस `Annotated` value को एक variable में store कर सकते हैं और कई जगहों पर उपयोग कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial001_02_an_py310.py hl[12,16,21] *}
+
+/// tip | सुझाव
+
+यह बस standard Python है, इसे "type alias" कहा जाता है, यह वास्तव में **FastAPI** के लिए specific नहीं है।
+
+लेकिन क्योंकि **FastAPI** Python standards पर आधारित है, जिसमें `Annotated` भी शामिल है, आप अपने code में इस trick का उपयोग कर सकते हैं। 😎
+
+///
+
+dependencies अपेक्षित रूप से काम करती रहेंगी, और **सबसे अच्छी बात** यह है कि **type information preserve रहेगी**, जिसका मतलब है कि आपका editor आपको **autocompletion**, **inline errors**, आदि प्रदान करना जारी रख सकेगा। यही बात `mypy` जैसे दूसरे tools के लिए भी लागू होती है।
+
+यह खास तौर पर तब उपयोगी होगा जब आप इसे एक **large code base** में उपयोग करते हैं जहाँ आप **वही dependencies** बार-बार **कई *path operations*** में उपयोग करते हैं।
+
+## `async` करें या `async` न करें { #to-async-or-not-to-async }
+
+क्योंकि dependencies को भी **FastAPI** द्वारा call किया जाएगा (आपके *path operation functions* की तरह), functions define करते समय वही rules लागू होते हैं।
+
+आप `async def` या सामान्य `def` का उपयोग कर सकते हैं।
+
+और आप normal `def` *path operation functions* के अंदर `async def` dependencies declare कर सकते हैं, या `async def` *path operation functions* के अंदर `def` dependencies, आदि।
+
+इससे फर्क नहीं पड़ता। **FastAPI** जानता होगा कि क्या करना है।
+
+/// note | नोट
+
+अगर आपको नहीं पता, तो docs में `async` और `await` के बारे में [Async: *"In a hurry?"*](../../async.md#in-a-hurry) section देखें।
+
+///
+
+## OpenAPI के साथ integrated { #integrated-with-openapi }
+
+आपकी dependencies (और sub-dependencies) की सभी request declarations, validations और requirements उसी OpenAPI schema में integrate की जाएँगी।
+
+इसलिए, interactive docs में इन dependencies की सारी जानकारी भी होगी:
+
+<img src="/img/tutorial/dependencies/image01.png">
+
+## सरल उपयोग { #simple-usage }
+
+अगर आप इसे देखें, तो *path operation functions* इस तरह declare किए जाते हैं कि जब भी कोई *path* और *operation* match करता है, उनका उपयोग किया जाए, और फिर **FastAPI** सही parameters के साथ function को call करने और request से data extract करने का ध्यान रखता है।
+
+असल में, सभी (या अधिकांश) web frameworks इसी तरह काम करते हैं।
+
+आप उन functions को कभी सीधे call नहीं करते। वे आपके framework द्वारा call किए जाते हैं (इस मामले में, **FastAPI**)।
+
+Dependency Injection system के साथ, आप **FastAPI** को यह भी बता सकते हैं कि आपका *path operation function* किसी और चीज़ पर भी "depend" करता है जिसे आपके *path operation function* से पहले execute किया जाना चाहिए, और **FastAPI** उसे execute करने और results को "inject" करने का ध्यान रखेगा।
+
+"dependency injection" के इसी idea के लिए अन्य common terms हैं:
+
+* resources
+* providers
+* services
+* injectables
+* components
+
+## **FastAPI** plug-ins { #fastapi-plug-ins }
+
+Integrations और "plug-ins" **Dependency Injection** system का उपयोग करके बनाए जा सकते हैं। लेकिन वास्तव में, **"plug-ins" बनाने की कोई ज़रूरत नहीं है**, क्योंकि dependencies का उपयोग करके अनगिनत integrations और interactions declare किए जा सकते हैं जो आपके *path operation functions* के लिए उपलब्ध हो जाते हैं।
+
+और dependencies को बहुत सरल और सहज तरीके से बनाया जा सकता है, जिससे आप बस अपने required Python packages import कर सकते हैं, और उन्हें अपने API functions के साथ कुछ lines of code में integrate कर सकते हैं, *literally*।
+
+आप अगले chapters में relational और NoSQL databases, security, आदि के बारे में इसके examples देखेंगे।
+
+## **FastAPI** compatibility { #fastapi-compatibility }
+
+Dependency injection system की सरलता **FastAPI** को इनके साथ compatible बनाती है:
+
+* सभी relational databases
+* NoSQL databases
+* external packages
+* external APIs
+* authentication और authorization systems
+* API usage monitoring systems
+* response data injection systems
+* आदि।
+
+## सरल और शक्तिशाली { #simple-and-powerful }
+
+हालाँकि hierarchical dependency injection system को define और use करना बहुत सरल है, फिर भी यह बहुत शक्तिशाली है।
+
+आप ऐसी dependencies define कर सकते हैं जो बदले में खुद dependencies define कर सकती हैं।
+
+अंत में, dependencies का एक hierarchical tree बनता है, और **Dependency Injection** system आपके लिए इन सभी dependencies (और उनकी sub-dependencies) को solve करने और हर step पर results प्रदान करने (inject करने) का ध्यान रखता है।
+
+उदाहरण के लिए, मान लें कि आपके पास 4 API endpoints (*path operations*) हैं:
+
+* `/items/public/`
+* `/items/private/`
+* `/users/{user_id}/activate`
+* `/items/pro/`
+
+तो आप उनमें से हर एक के लिए अलग-अलग permission requirements केवल dependencies और sub-dependencies के साथ जोड़ सकते हैं:
+
+```mermaid
+graph TB
+
+current_user(["current_user"])
+active_user(["active_user"])
+admin_user(["admin_user"])
+paying_user(["paying_user"])
+
+public["/items/public/"]
+private["/items/private/"]
+activate_user["/users/{user_id}/activate"]
+pro_items["/items/pro/"]
+
+current_user --> active_user
+active_user --> admin_user
+active_user --> paying_user
+
+current_user --> public
+active_user --> private
+admin_user --> activate_user
+paying_user --> pro_items
+```
+
+## **OpenAPI** के साथ integrated { #integrated-with-openapi_1 }
+
+ये सभी dependencies, अपनी requirements declare करते समय, आपके *path operations* में parameters, validations, आदि भी जोड़ती हैं।
+
+**FastAPI** यह सब OpenAPI schema में जोड़ने का ध्यान रखेगा, ताकि यह interactive documentation systems में दिखाया जा सके।

docs/hi/docs/tutorial/dependencies/sub-dependencies.md

@@ -0,0 +1,105 @@
+# Sub-dependencies { #sub-dependencies }
+
+आप ऐसी dependencies बना सकते हैं जिनकी अपनी **sub-dependencies** हों।
+
+वे उतनी **deep** हो सकती हैं जितनी आपको चाहिए।
+
+**FastAPI** उन्हें solve करने का ध्यान रखेगा।
+
+## पहली dependency "dependable" { #first-dependency-dependable }
+
+आप पहली dependency ("dependable") इस तरह बना सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}
+
+यह एक optional query parameter `q` को `str` के रूप में declare करता है, और फिर बस उसे return करता है।
+
+यह काफी सरल है (बहुत उपयोगी नहीं), लेकिन इससे हमें यह समझने पर ध्यान देने में मदद मिलेगी कि sub-dependencies कैसे काम करती हैं।
+
+## दूसरी dependency, "dependable" और "dependant" { #second-dependency-dependable-and-dependant }
+
+फिर आप एक और dependency function (एक "dependable") बना सकते हैं जो उसी समय अपनी खुद की dependency declare करता है (इसलिए यह एक "dependant" भी है):
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[13] *}
+
+आइए declared parameters पर ध्यान दें:
+
+* भले ही यह function खुद एक dependency ("dependable") है, यह एक और dependency भी declare करता है (यह किसी और चीज़ पर "depends" करता है)।
+    * यह `query_extractor` पर depends करता है, और उसके द्वारा return किए गए value को parameter `q` में assign करता है।
+* यह एक optional `last_query` cookie को भी `str` के रूप में declare करता है।
+    * अगर user ने कोई query `q` provide नहीं की, तो हम पिछली इस्तेमाल की गई query का उपयोग करते हैं, जिसे हमने पहले एक cookie में save किया था।
+
+## dependency का उपयोग करें { #use-the-dependency }
+
+फिर हम dependency का उपयोग इस तरह कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[23] *}
+
+/// note | नोट
+
+ध्यान दें कि हम *path operation function* में केवल एक dependency declare कर रहे हैं, `query_or_cookie_extractor`।
+
+लेकिन **FastAPI** को पता होगा कि `query_or_cookie_extractor` को call करते समय उसके results pass करने के लिए पहले `query_extractor` को solve करना है।
+
+///
+
+```mermaid
+graph TB
+
+query_extractor(["query_extractor"])
+query_or_cookie_extractor(["query_or_cookie_extractor"])
+
+read_query["/items/"]
+
+query_extractor --> query_or_cookie_extractor --> read_query
+```
+
+## उसी dependency को कई बार उपयोग करना { #using-the-same-dependency-multiple-times }
+
+अगर आपकी किसी dependency को उसी *path operation* के लिए कई बार declare किया गया है, उदाहरण के लिए, कई dependencies की कोई common sub-dependency है, तो **FastAPI** जानता होगा कि उस sub-dependency को प्रति request केवल एक बार call करना है।
+
+और यह return किए गए value को एक <dfn title="computed/generated values को store करने और उन्हें फिर से compute करने के बजाय reuse करने के लिए एक utility/system">"cache"</dfn> में save करेगा और उसे उन सभी "dependants" को pass करेगा जिन्हें उस specific request में इसकी ज़रूरत है, बजाय उसी request के लिए dependency को कई बार call करने के।
+
+एक advanced scenario में, जहाँ आप जानते हैं कि आपको उसी request में "cached" value का उपयोग करने के बजाय हर step पर dependency को call करवाना है (संभवतः कई बार), आप `Depends` का उपयोग करते समय parameter `use_cache=False` set कर सकते हैं:
+
+//// tab | Python 3.10+
+
+```Python hl_lines="1"
+async def needy_dependency(fresh_value: Annotated[str, Depends(get_value, use_cache=False)]):
+    return {"fresh_value": fresh_value}
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+अगर संभव हो तो `Annotated` version का उपयोग करना पसंद करें।
+
+///
+
+```Python hl_lines="1"
+async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False)):
+    return {"fresh_value": fresh_value}
+```
+
+////
+
+## Recap { #recap }
+
+यहाँ इस्तेमाल किए गए सभी fancy words को छोड़ दें, तो **Dependency Injection** system काफी सरल है।
+
+बस ऐसे functions जो *path operation functions* जैसे ही दिखते हैं।
+
+लेकिन फिर भी, यह बहुत powerful है, और आपको arbitrarily deeply nested dependency "graphs" (trees) declare करने देता है।
+
+/// tip | सुझाव
+
+इन सरल examples के साथ यह सब इतना उपयोगी नहीं लग सकता।
+
+लेकिन **security** के बारे में chapters में आप देखेंगे कि यह कितना उपयोगी है।
+
+और आप यह भी देखेंगे कि यह आपका कितना code बचाएगा।
+
+///

docs/hi/docs/tutorial/encoder.md

@@ -0,0 +1,35 @@
+# JSON संगत Encoder { #json-compatible-encoder }
+
+कुछ मामलों में आपको किसी data type (जैसे Pydantic model) को JSON के साथ संगत किसी चीज़ (जैसे `dict`, `list`, आदि) में convert करने की ज़रूरत पड़ सकती है।
+
+उदाहरण के लिए, अगर आपको इसे database में store करना हो।
+
+इसके लिए, **FastAPI** एक `jsonable_encoder()` function प्रदान करता है।
+
+## `jsonable_encoder` का उपयोग करना { #using-the-jsonable-encoder }
+
+कल्पना करें कि आपके पास एक database `fake_db` है जो केवल JSON संगत data ही स्वीकार करता है।
+
+उदाहरण के लिए, यह `datetime` objects स्वीकार नहीं करता, क्योंकि वे JSON के साथ संगत नहीं होते।
+
+इसलिए, एक `datetime` object को [ISO format](https://en.wikipedia.org/wiki/ISO_8601) में data रखने वाले `str` में convert करना होगा।
+
+इसी तरह, यह database Pydantic model (attributes वाला एक object) स्वीकार नहीं करेगा, केवल एक `dict`।
+
+इसके लिए आप `jsonable_encoder` का उपयोग कर सकते हैं।
+
+यह एक object, जैसे Pydantic model, प्राप्त करता है और JSON संगत version लौटाता है:
+
+{* ../../docs_src/encoder/tutorial001_py310.py hl[4,21] *}
+
+इस उदाहरण में, यह Pydantic model को `dict` में और `datetime` को `str` में convert करेगा।
+
+इसे call करने का परिणाम कुछ ऐसा होता है जिसे Python standard [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps) के साथ encode किया जा सकता है।
+
+यह JSON format में data रखने वाला कोई बड़ा `str` (string के रूप में) return नहीं करता। यह एक Python standard data structure (जैसे `dict`) return करता है, जिसमें values और sub-values होती हैं जो सभी JSON के साथ संगत होती हैं।
+
+/// note | नोट
+
+`jsonable_encoder` वास्तव में **FastAPI** द्वारा internally data convert करने के लिए उपयोग किया जाता है। लेकिन यह कई अन्य scenarios में भी उपयोगी है।
+
+///

docs/hi/docs/tutorial/extra-data-types.md

@@ -0,0 +1,62 @@
+# अतिरिक्त Data Types { #extra-data-types }
+
+अब तक, आप सामान्य data types का उपयोग करते रहे हैं, जैसे:
+
+* `int`
+* `float`
+* `str`
+* `bool`
+
+लेकिन आप अधिक जटिल data types भी उपयोग कर सकते हैं।
+
+और आपको अब तक देखी गई वही features मिलती रहेंगी:
+
+* शानदार editor support.
+* आने वाली requests से data conversion.
+* response data के लिए data conversion.
+* Data validation.
+* Automatic annotation और documentation.
+
+## अन्य data types { #other-data-types }
+
+यहाँ कुछ अतिरिक्त data types हैं जिनका आप उपयोग कर सकते हैं:
+
+* `UUID`:
+    * एक standard "Universally Unique Identifier", जो कई databases और systems में ID के रूप में आम है।
+    * requests और responses में इसे `str` के रूप में दर्शाया जाएगा।
+* `datetime.datetime`:
+    * एक Python `datetime.datetime`.
+    * requests और responses में इसे ISO 8601 format में `str` के रूप में दर्शाया जाएगा, जैसे: `2008-09-15T15:53:00+05:00`.
+* `datetime.date`:
+    * Python `datetime.date`.
+    * requests और responses में इसे ISO 8601 format में `str` के रूप में दर्शाया जाएगा, जैसे: `2008-09-15`.
+* `datetime.time`:
+    * एक Python `datetime.time`.
+    * requests और responses में इसे ISO 8601 format में `str` के रूप में दर्शाया जाएगा, जैसे: `14:23:55.003`.
+* `datetime.timedelta`:
+    * एक Python `datetime.timedelta`.
+    * requests और responses में इसे कुल seconds के `float` के रूप में दर्शाया जाएगा।
+    * Pydantic इसे "ISO 8601 time diff encoding" के रूप में दर्शाने की अनुमति भी देता है, [अधिक जानकारी के लिए docs देखें](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
+* `frozenset`:
+    * requests और responses में, इसे `set` जैसा ही माना जाता है:
+        * requests में, एक list पढ़ी जाएगी, duplicates हटाए जाएँगे और उसे `set` में convert किया जाएगा।
+        * responses में, `set` को `list` में convert किया जाएगा।
+        * generate किया गया schema बताएगा कि `set` values unique हैं (JSON Schema के `uniqueItems` का उपयोग करते हुए)।
+* `bytes`:
+    * Standard Python `bytes`.
+    * requests और responses में इसे `str` की तरह माना जाएगा।
+    * generate किया गया schema बताएगा कि यह `binary` "format" वाला `str` है।
+* `Decimal`:
+    * Standard Python `Decimal`.
+    * requests और responses में, इसे `float` जैसा ही handle किया जाएगा।
+* आप सभी valid Pydantic data types यहाँ देख सकते हैं: [Pydantic data types](https://docs.pydantic.dev/latest/usage/types/types/).
+
+## उदाहरण { #example }
+
+यहाँ ऊपर दिए गए कुछ types का उपयोग करते हुए parameters वाला एक उदाहरण *path operation* है।
+
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}
+
+ध्यान दें कि function के अंदर parameters के अपने natural data type होते हैं, और उदाहरण के लिए, आप सामान्य date manipulations कर सकते हैं, जैसे:
+
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[18:19] *}

docs/hi/docs/tutorial/extra-models.md

@@ -0,0 +1,211 @@
+# Extra Models { #extra-models }
+
+पिछले उदाहरण को आगे बढ़ाते हुए, एक से अधिक संबंधित model होना आम बात होगी।
+
+यह खासकर user models के मामले में होता है, क्योंकि:
+
+* **input model** में password हो सकने की क्षमता चाहिए।
+* **output model** में password नहीं होना चाहिए।
+* **database model** में शायद hashed password होना चाहिए।
+
+/// danger | खतरा
+
+user के plaintext passwords कभी store न करें। हमेशा एक "secure hash" store करें जिसे आप बाद में verify कर सकें।
+
+अगर आप नहीं जानते, तो आप [security chapters](security/simple-oauth2.md#password-hashing) में सीखेंगे कि "password hash" क्या होता है।
+
+///
+
+## कई models { #multiple-models }
+
+यह एक सामान्य idea है कि models अपने password fields और जहाँ वे इस्तेमाल होते हैं, वहाँ कैसे दिख सकते हैं:
+
+{* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
+
+### `**user_in.model_dump()` के बारे में { #about-user-in-model-dump }
+
+#### Pydantic का `.model_dump()` { #pydantics-model-dump }
+
+`user_in`, class `UserIn` का एक Pydantic model है।
+
+Pydantic models में एक `.model_dump()` method होता है जो model के data के साथ एक `dict` return करता है।
+
+तो, अगर हम इस तरह एक Pydantic object `user_in` बनाते हैं:
+
+```Python
+user_in = UserIn(username="john", password="secret", email="[email protected]")
+```
+
+और फिर हम call करते हैं:
+
+```Python
+user_dict = user_in.model_dump()
+```
+
+तो अब हमारे पास variable `user_dict` में data के साथ एक `dict` है (यह Pydantic model object के बजाय एक `dict` है)।
+
+और अगर हम call करते हैं:
+
+```Python
+print(user_dict)
+```
+
+तो हमें यह Python `dict` मिलेगा:
+
+```Python
+{
+    'username': 'john',
+    'password': 'secret',
+    'email': '[email protected]',
+    'full_name': None,
+}
+```
+
+#### एक `dict` को unpack करना { #unpacking-a-dict }
+
+अगर हम `user_dict` जैसा एक `dict` लेते हैं और उसे किसी function (या class) को `**user_dict` के साथ pass करते हैं, तो Python उसे "unpack" करेगा। यह `user_dict` की keys और values को सीधे key-value arguments के रूप में pass करेगा।
+
+तो, ऊपर वाले `user_dict` को जारी रखते हुए, यह लिखना:
+
+```Python
+UserInDB(**user_dict)
+```
+
+कुछ इस equivalent result देगा:
+
+```Python
+UserInDB(
+    username="john",
+    password="secret",
+    email="[email protected]",
+    full_name=None,
+)
+```
+
+या अधिक सही रूप में, `user_dict` को सीधे इस्तेमाल करते हुए, उसमें भविष्य में जो भी contents हों:
+
+```Python
+UserInDB(
+    username = user_dict["username"],
+    password = user_dict["password"],
+    email = user_dict["email"],
+    full_name = user_dict["full_name"],
+)
+```
+
+#### दूसरे model के contents से एक Pydantic model { #a-pydantic-model-from-the-contents-of-another }
+
+जैसा कि ऊपर के उदाहरण में हमें `user_in.model_dump()` से `user_dict` मिला, यह code:
+
+```Python
+user_dict = user_in.model_dump()
+UserInDB(**user_dict)
+```
+
+इसके equivalent होगा:
+
+```Python
+UserInDB(**user_in.model_dump())
+```
+
+...क्योंकि `user_in.model_dump()` एक `dict` है, और फिर हम उसे `**` prefix के साथ `UserInDB` को pass करके Python से उसे "unpack" करवाते हैं।
+
+तो, हमें एक Pydantic model के data से दूसरा Pydantic model मिलता है।
+
+#### एक `dict` को unpack करना और extra keywords { #unpacking-a-dict-and-extra-keywords }
+
+और फिर extra keyword argument `hashed_password=hashed_password` जोड़ना, जैसे:
+
+```Python
+UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
+```
+
+...अंत में ऐसा बन जाता है:
+
+```Python
+UserInDB(
+    username = user_dict["username"],
+    password = user_dict["password"],
+    email = user_dict["email"],
+    full_name = user_dict["full_name"],
+    hashed_password = hashed_password,
+)
+```
+
+/// warning | चेतावनी
+
+supporting additional functions `fake_password_hasher` और `fake_save_user` सिर्फ data के एक possible flow को demo करने के लिए हैं, लेकिन वे निश्चित रूप से कोई real security नहीं दे रहे हैं।
+
+///
+
+## Duplication कम करें { #reduce-duplication }
+
+Code duplication कम करना **FastAPI** के core ideas में से एक है।
+
+क्योंकि code duplication बढ़ने से bugs, security issues, code desynchronization issues (जब आप एक जगह update करते हैं लेकिन बाकी जगह नहीं), आदि की संभावना बढ़ जाती है।
+
+और ये models बहुत सारा data share कर रहे हैं और attribute names और types को duplicate कर रहे हैं।
+
+हम इससे बेहतर कर सकते हैं।
+
+हम एक `UserBase` model declare कर सकते हैं जो हमारे दूसरे models के लिए base की तरह काम करता है। और फिर हम उस model की subclasses बना सकते हैं जो उसके attributes (type declarations, validation, आदि) inherit करती हैं।
+
+सारा data conversion, validation, documentation, आदि सामान्य रूप से काम करता रहेगा।
+
+इस तरह, हम केवल models के बीच के अंतर declare कर सकते हैं (plaintext `password` के साथ, `hashed_password` के साथ और password के बिना):
+
+{* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *}
+
+## `Union` या `anyOf` { #union-or-anyof }
+
+आप response को दो या अधिक types के `Union` के रूप में declare कर सकते हैं, जिसका मतलब है कि response उनमें से कोई भी हो सकता है।
+
+इसे OpenAPI में `anyOf` के साथ define किया जाएगा।
+
+ऐसा करने के लिए, standard Python type hint [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union) का इस्तेमाल करें:
+
+/// note | नोट
+
+[`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions) define करते समय, सबसे specific type को पहले include करें, उसके बाद कम specific type को। नीचे दिए गए उदाहरण में, अधिक specific `PlaneItem`, `Union[PlaneItem, CarItem]` में `CarItem` से पहले आता है।
+
+///
+
+{* ../../docs_src/extra_models/tutorial003_py310.py hl[1,14:15,18:20,33] *}
+
+### Python 3.10 में `Union` { #union-in-python-3-10 }
+
+इस उदाहरण में हम argument `response_model` की value के रूप में `Union[PlaneItem, CarItem]` pass करते हैं।
+
+क्योंकि हम इसे **type annotation** में रखने के बजाय **argument को value** के रूप में pass कर रहे हैं, इसलिए हमें Python 3.10 में भी `Union` इस्तेमाल करना होगा।
+
+अगर यह type annotation में होता तो हम vertical bar इस्तेमाल कर सकते थे, जैसे:
+
+```Python
+some_variable: PlaneItem | CarItem
+```
+
+लेकिन अगर हम इसे assignment `response_model=PlaneItem | CarItem` में डालते, तो हमें error मिलता, क्योंकि Python इसे type annotation के रूप में interpret करने के बजाय `PlaneItem` और `CarItem` के बीच एक **invalid operation** perform करने की कोशिश करता।
+
+## Models की list { #list-of-models }
+
+इसी तरह, आप objects की lists के responses declare कर सकते हैं।
+
+इसके लिए, standard Python `list` इस्तेमाल करें:
+
+{* ../../docs_src/extra_models/tutorial004_py310.py hl[18] *}
+
+## Arbitrary `dict` के साथ response { #response-with-arbitrary-dict }
+
+आप plain arbitrary `dict` का इस्तेमाल करके भी response declare कर सकते हैं, जिसमें Pydantic model का इस्तेमाल किए बिना केवल keys और values का type declare किया जाता है।
+
+यह तब उपयोगी है जब आपको valid field/attribute names (जो Pydantic model के लिए चाहिए होंगे) पहले से नहीं पता हों।
+
+इस मामले में, आप `dict` इस्तेमाल कर सकते हैं:
+
+{* ../../docs_src/extra_models/tutorial005_py310.py hl[6] *}
+
+## Recap { #recap }
+
+हर case के लिए कई Pydantic models इस्तेमाल करें और freely inherit करें।
+
+अगर किसी entity में अलग-अलग "states" हो सकने चाहिए, तो आपको प्रति entity एक ही data model रखने की जरूरत नहीं है। **user** "entity" एक उदाहरण है, जिसमें states में `password`, `password_hash`, या कोई password नहीं होना शामिल है।

docs/hi/docs/tutorial/first-steps.md

@@ -0,0 +1,421 @@
+# पहले कदम { #first-steps }
+
+सबसे सरल FastAPI file ऐसी दिख सकती है:
+
+{* ../../docs_src/first_steps/tutorial001_py310.py *}
+
+इसे `main.py` नाम की file में copy करें।
+
+live server चलाएँ:
+
+<div class="termy">
+
+```console
+$ <font color="#4E9A06">fastapi</font> dev
+
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
+
+             Searching for package file structure from directories
+             with <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
+             the following code:
+
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
+             to quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+```
+
+</div>
+
+output में, कुछ ऐसी एक line होती है:
+
+```hl_lines="4"
+INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+यह line वह URL दिखाती है जहाँ आपकी app आपकी local machine पर serve की जा रही है।
+
+### इसे जाँचें { #check-it }
+
+अपने browser में [http://127.0.0.1:8000](http://127.0.0.1:8000) खोलें।
+
+आपको JSON response इस तरह दिखेगा:
+
+```JSON
+{"message": "Hello World"}
+```
+
+### Interactive API docs { #interactive-api-docs }
+
+अब [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) पर जाएँ।
+
+आपको automatic interactive API documentation दिखेगी ([Swagger UI](https://github.com/swagger-api/swagger-ui) द्वारा प्रदान की गई):
+
+![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
+
+### वैकल्पिक API docs { #alternative-api-docs }
+
+और अब, [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) पर जाएँ।
+
+आपको वैकल्पिक automatic documentation दिखेगी ([ReDoc](https://github.com/Rebilly/ReDoc) द्वारा प्रदान की गई):
+
+![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
+
+### OpenAPI { #openapi }
+
+**FastAPI** APIs को define करने के लिए **OpenAPI** standard का उपयोग करके आपकी पूरी API के साथ एक "schema" generate करता है।
+
+#### "Schema" { #schema }
+
+"schema" किसी चीज़ की definition या description है। वह code नहीं जो इसे implement करता है, बल्कि सिर्फ़ एक abstract description है।
+
+#### API "schema" { #api-schema }
+
+इस मामले में, [OpenAPI](https://github.com/OAI/OpenAPI-Specification) एक specification है जो बताती है कि आपकी API का schema कैसे define करना है।
+
+इस schema definition में आपकी API paths, उनके द्वारा लिए जा सकने वाले संभावित parameters आदि शामिल होते हैं।
+
+#### Data "schema" { #data-schema }
+
+"schema" शब्द कुछ data के आकार को भी refer कर सकता है, जैसे JSON content।
+
+उस मामले में, इसका मतलब JSON attributes, और उनके data types आदि होगा।
+
+#### OpenAPI और JSON Schema { #openapi-and-json-schema }
+
+OpenAPI आपकी API के लिए API schema define करता है। और उस schema में **JSON Schema**, जो JSON data schemas के लिए standard है, का उपयोग करके आपकी API द्वारा भेजे और प्राप्त किए गए data की definitions (या "schemas") शामिल होती हैं।
+
+#### `openapi.json` जाँचें { #check-the-openapi-json }
+
+अगर आप यह जानने को उत्सुक हैं कि raw OpenAPI schema कैसा दिखता है, FastAPI आपकी पूरी API के descriptions के साथ अपने आप एक JSON (schema) generate करता है।
+
+आप इसे सीधे यहाँ देख सकते हैं: [http://127.0.0.1:8000/openapi.json](http://127.0.0.1:8000/openapi.json)।
+
+यह कुछ ऐसे शुरू होने वाला JSON दिखाएगा:
+
+```JSON
+{
+    "openapi": "3.1.0",
+    "info": {
+        "title": "FastAPI",
+        "version": "0.1.0"
+    },
+    "paths": {
+        "/items/": {
+            "get": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {
+                            "application/json": {
+
+
+
+...
+```
+
+#### OpenAPI किसलिए है { #what-is-openapi-for }
+
+OpenAPI schema ही शामिल किए गए दो interactive documentation systems को power देता है।
+
+और दर्जनों विकल्प हैं, सभी OpenAPI पर आधारित। आप **FastAPI** से बनी अपनी application में इनमें से कोई भी विकल्प आसानी से जोड़ सकते हैं।
+
+आप इसका उपयोग उन clients के लिए अपने आप code generate करने के लिए भी कर सकते हैं जो आपकी API से communicate करते हैं। उदाहरण के लिए, frontend, mobile या IoT applications।
+
+### `pyproject.toml` में app `entrypoint` configure करें { #configure-the-app-entrypoint-in-pyproject-toml }
+
+आप `pyproject.toml` file में अपनी app कहाँ स्थित है, इसे इस तरह configure कर सकते हैं:
+
+```toml
+[tool.fastapi]
+entrypoint = "main:app"
+```
+
+वह `entrypoint` `fastapi` command को बताएगा कि उसे app को इस तरह import करना चाहिए:
+
+```python
+from main import app
+```
+
+अगर आपका code इस तरह structured था:
+
+```
+.
+├── backend
+│   ├── main.py
+│   ├── __init__.py
+```
+
+तो आप `entrypoint` को इस तरह set करेंगे:
+
+```toml
+[tool.fastapi]
+entrypoint = "backend.main:app"
+```
+
+जो इसके equivalent होगा:
+
+```python
+from backend.main import app
+```
+
+### `fastapi dev` path के साथ या `--entrypoint` CLI option के साथ { #fastapi-dev-with-path-or-with-entrypoint-cli-option }
+
+आप `fastapi dev` command को file path भी pass कर सकते हैं, और यह उपयोग करने के लिए FastAPI app object का अनुमान लगा लेगा:
+
+```console
+$ fastapi dev main.py
+```
+
+या, आप `fastapi dev` command को `--entrypoint` option भी pass कर सकते हैं:
+
+```console
+$ fastapi dev --entrypoint main:app
+```
+
+लेकिन हर बार `fastapi` command call करते समय आपको सही path\entrypoint pass करना याद रखना होगा।
+
+इसके अलावा, दूसरे tools इसे ढूँढ नहीं पाएँगे, उदाहरण के लिए [VS Code Extension](../editor-support.md) या [FastAPI Cloud](https://fastapicloud.com), इसलिए `pyproject.toml` में `entrypoint` का उपयोग करने की सलाह दी जाती है।
+
+### अपनी app deploy करें (वैकल्पिक) { #deploy-your-app-optional }
+
+आप वैकल्पिक रूप से अपनी FastAPI app को एक single command से [FastAPI Cloud](https://fastapicloud.com) पर deploy कर सकते हैं। 🚀
+
+<div class="termy">
+
+```console
+$ fastapi deploy
+
+Deploying to FastAPI Cloud...
+
+✅ Deployment successful!
+
+🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
+```
+
+</div>
+
+CLI आपकी FastAPI application को अपने आप detect करेगा और उसे cloud पर deploy करेगा। अगर आप logged in नहीं हैं, तो authentication process पूरा करने के लिए आपका browser खुलेगा।
+
+बस इतना ही! अब आप उस URL पर अपनी app access कर सकते हैं। ✨
+
+## Recap, चरण दर चरण { #recap-step-by-step }
+
+### चरण 1: `FastAPI` import करें { #step-1-import-fastapi }
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[1] *}
+
+`FastAPI` एक Python class है जो आपकी API के लिए सारी functionality प्रदान करती है।
+
+/// note | तकनीकी विवरण
+
+`FastAPI` एक class है जो सीधे `Starlette` से inherit करती है।
+
+आप `FastAPI` के साथ सारी [Starlette](https://www.starlette.dev/) functionality भी उपयोग कर सकते हैं।
+
+///
+
+### चरण 2: एक `FastAPI` "instance" बनाएँ { #step-2-create-a-fastapi-instance }
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[3] *}
+
+यहाँ `app` variable class `FastAPI` का एक "instance" होगा।
+
+यह आपकी पूरी API बनाने के लिए interaction का मुख्य point होगा।
+
+### चरण 3: एक *path operation* बनाएँ { #step-3-create-a-path-operation }
+
+#### Path { #path }
+
+यहाँ "Path" URL के पहले `/` से शुरू होने वाले आख़िरी हिस्से को refer करता है।
+
+तो, ऐसे URL में:
+
+```
+https://example.com/items/foo
+```
+
+...path होगा:
+
+```
+/items/foo
+```
+
+/// note | नोट
+
+एक "path" को आमतौर पर "endpoint" या "route" भी कहा जाता है।
+
+///
+
+API बनाते समय, "path" "concerns" और "resources" को अलग करने का मुख्य तरीका है।
+
+#### Operation { #operation }
+
+यहाँ "Operation" HTTP "methods" में से किसी एक को refer करता है।
+
+इनमें से एक:
+
+* `POST`
+* `GET`
+* `PUT`
+* `DELETE`
+
+...और कुछ अधिक असामान्य वाले:
+
+* `OPTIONS`
+* `HEAD`
+* `PATCH`
+* `TRACE`
+
+HTTP protocol में, आप इन "methods" में से एक (या अधिक) का उपयोग करके हर path से communicate कर सकते हैं।
+
+---
+
+APIs बनाते समय, आप आमतौर पर कोई specific action करने के लिए इन specific HTTP methods का उपयोग करते हैं।
+
+आम तौर पर आप उपयोग करते हैं:
+
+* `POST`: data बनाने के लिए।
+* `GET`: data पढ़ने के लिए।
+* `PUT`: data update करने के लिए।
+* `DELETE`: data delete करने के लिए।
+
+इसलिए, OpenAPI में, हर HTTP method को एक "operation" कहा जाता है।
+
+हम उन्हें भी "**operations**" कहेंगे।
+
+#### एक *path operation decorator* define करें { #define-a-path-operation-decorator }
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[6] *}
+
+`@app.get("/")` **FastAPI** को बताता है कि ठीक नीचे वाला function उन requests को handle करने का प्रभारी है जो यहाँ जाती हैं:
+
+* path `/`
+* <dfn title="एक HTTP GET method"><code>get</code> operation</dfn> का उपयोग करते हुए
+
+/// note | `@decorator` जानकारी
+
+Python में उस `@something` syntax को "decorator" कहा जाता है।
+
+आप इसे किसी function के ऊपर लगाते हैं। जैसे एक सुंदर सजावटी टोपी (मुझे लगता है term वहीं से आया है)।
+
+एक "decorator" नीचे वाले function को लेता है और उसके साथ कुछ करता है।
+
+हमारे मामले में, यह decorator **FastAPI** को बताता है कि नीचे वाला function **path** `/` के साथ **operation** `get` से संबंधित है।
+
+यह "**path operation decorator**" है।
+
+///
+
+आप दूसरे operations भी उपयोग कर सकते हैं:
+
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+
+और कुछ अधिक असामान्य वाले:
+
+* `@app.options()`
+* `@app.head()`
+* `@app.patch()`
+* `@app.trace()`
+
+/// tip | सुझाव
+
+आप हर operation (HTTP method) को अपनी इच्छा के अनुसार उपयोग करने के लिए स्वतंत्र हैं।
+
+**FastAPI** कोई specific अर्थ enforce नहीं करता।
+
+यहाँ दी गई जानकारी guideline के रूप में प्रस्तुत की गई है, requirement के रूप में नहीं।
+
+उदाहरण के लिए, GraphQL का उपयोग करते समय आप आम तौर पर सभी actions केवल `POST` operations का उपयोग करके करते हैं।
+
+///
+
+### चरण 4: **path operation function** define करें { #step-4-define-the-path-operation-function }
+
+यह हमारा "**path operation function**" है:
+
+* **path**: `/` है।
+* **operation**: `get` है।
+* **function**: "decorator" के नीचे वाला function है (`@app.get("/")` के नीचे)।
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[7] *}
+
+यह एक Python function है।
+
+जब भी **FastAPI** को `GET` operation का उपयोग करके URL "`/`" पर कोई request मिलती है, तो यह इसे call करेगा।
+
+इस मामले में, यह एक `async` function है।
+
+---
+
+आप इसे `async def` के बजाय normal function के रूप में भी define कर सकते हैं:
+
+{* ../../docs_src/first_steps/tutorial003_py310.py hl[7] *}
+
+/// note | नोट
+
+अगर आपको अंतर नहीं पता है, तो [Async: *"In a hurry?"*](../async.md#in-a-hurry) देखें।
+
+///
+
+### चरण 5: content return करें { #step-5-return-the-content }
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[8] *}
+
+आप `dict`, `list`, `str`, `int` आदि जैसे singular values return कर सकते हैं।
+
+आप Pydantic models भी return कर सकते हैं (इसके बारे में आप आगे और देखेंगे)।
+
+कई अन्य objects और models हैं जिन्हें अपने आप JSON में convert किया जाएगा (ORMs आदि सहित)। अपने पसंदीदा ones उपयोग करके देखें, बहुत संभावना है कि वे पहले से supported हों।
+
+### चरण 6: इसे Deploy करें { #step-6-deploy-it }
+
+अपनी app को **[FastAPI Cloud](https://fastapicloud.com)** पर एक command से deploy करें: `fastapi deploy`। 🎉
+
+#### FastAPI Cloud के बारे में { #about-fastapi-cloud }
+
+**[FastAPI Cloud](https://fastapicloud.com)** को **FastAPI** के पीछे मौजूद उसी author और team ने बनाया है।
+
+यह कम से कम प्रयास के साथ API को **बनाने**, **deploy करने**, और **access करने** की process को streamlined करता है।
+
+यह FastAPI के साथ apps बनाने जैसा ही **developer experience**, उन्हें cloud पर **deploy** करने में लाता है। 🎉
+
+FastAPI Cloud *FastAPI and friends* open source projects का प्राथमिक sponsor और funding provider है। ✨
+
+#### दूसरे cloud providers पर deploy करें { #deploy-to-other-cloud-providers }
+
+FastAPI open source है और standards पर आधारित है। आप FastAPI apps को अपनी पसंद के किसी भी cloud provider पर deploy कर सकते हैं।
+
+FastAPI apps को उनके साथ deploy करने के लिए अपने cloud provider की guides follow करें। 🤓
+
+## Recap { #recap }
+
+* `FastAPI` import करें।
+* एक `app` instance बनाएँ।
+* `@app.get("/")` जैसे decorators का उपयोग करके एक **path operation decorator** लिखें।
+* एक **path operation function** define करें; उदाहरण के लिए, `def root(): ...`।
+* `fastapi dev` command का उपयोग करके development server चलाएँ।
+* वैकल्पिक रूप से अपनी app को `fastapi deploy` के साथ deploy करें।

docs/hi/docs/tutorial/frontend.md

@@ -0,0 +1,139 @@
+# Frontend { #frontend }
+
+आप `app.frontend()` (या `router.frontend()`) के साथ static frontend apps serve कर सकते हैं।
+
+यह उन frontend tools के लिए उपयोगी है जो static files generate करते हैं, जैसे React with Vite, TanStack Router, Astro, Vue, Svelte, Angular, Solid, और अन्य।
+
+इन tools के साथ, आपके पास आमतौर पर एक step होता है जो frontend को build करता है, जैसे इस command के साथ:
+
+```bash
+npm run build
+```
+
+यह आपके frontend files के साथ `./dist/` जैसी एक directory generate करेगा।
+
+आप उस directory को इन frontend frameworks के लिए required conventions के अनुसार serve करने के लिए `app.frontend()` का उपयोग कर सकते हैं।
+
+**FastAPI** पहले *path operations* की जाँच करता है। frontend files की जाँच केवल तब की जाती है जब कोई सामान्य route match नहीं हुआ हो, इसलिए आपकी API प्रभावित नहीं होगी।
+
+## Frontend Serve करें { #serve-a-frontend }
+
+अपना frontend build करने के बाद, उदाहरण के लिए `npm run build` के साथ, generate की गई files को किसी directory में रखें, उदाहरण के लिए, `dist`।
+
+आपकी project संरचना ऐसी दिख सकती है:
+
+```text
+.
+├── pyproject.toml
+├── app
+│   ├── __init__.py
+│   └── main.py
+└── dist
+    ├── index.html
+    └── assets
+        └── app.js
+```
+
+फिर इसे `app.frontend()` के साथ serve करें:
+
+{* ../../docs_src/frontend/tutorial001_py310.py hl[5] *}
+
+इसके साथ, `/assets/app.js` के लिए एक request `dist/assets/app.js` serve कर सकती है।
+
+अगर आपके पास एक **FastAPI** *path operation* भी है, तो *path operation* को प्राथमिकता मिलती है।
+
+## Client-Side Routing { #client-side-routing }
+
+कई frontend apps, जिनमें **single-page apps** (SPAs) शामिल हैं, client-side routing का उपयोग करते हैं। `/dashboard/settings` जैसा path असली file नहीं हो सकता है, लेकिन framework इसे handle करने का ध्यान रखेगा।
+
+इसलिए, अगर उस URL को सीधे access किया जा रहा है (app के अंदर navigate करने के बजाय), तो backend को frontend app को `index.html` से serve करना चाहिए, ताकि frontend framework फिर client-side routing को handle कर सके।
+
+इसके लिए, `fallback="index.html"` का उपयोग करें:
+
+{* ../../docs_src/frontend/tutorial002_py310.py hl[5] *}
+
+**FastAPI** इस fallback का उपयोग केवल उन `GET` और `HEAD` requests के लिए करता है जो browser navigation जैसी दिखती हैं। JavaScript, CSS, और images जैसी missing files अभी भी `404` लौटाती हैं।
+
+अन्य methods वाली requests, जैसे `POST` या `PUT`, उन paths पर जो केवल frontend fallback से match करते हैं, वे भी `404` लौटाती हैं। नियमित **FastAPI** *path operations* की priority अभी भी frontend routes से अधिक होती है।
+
+/// tip | सुझाव
+
+Default रूप से, `fallback` की value `fallback="auto"` होती है। अधिकतर मामलों में आपको `fallback` specify करने की ज़रूरत नहीं होगी। विवरण के लिए नीचे पढ़ें।
+
+///
+
+यह वही है जो आप कई frontend apps के साथ चाहेंगे जो client-side routing का उपयोग करते हैं, उदाहरण के लिए, React with TanStack Router, Vue, Angular, SvelteKit, या Solid।
+
+## Custom 404 Page { #custom-404-page }
+
+आप missing frontend paths के लिए static `404.html` page भी serve कर सकते हैं:
+
+{* ../../docs_src/frontend/tutorial003_py310.py hl[5] *}
+
+वह response `404` का status code बनाए रखती है।
+
+इस मामले में, **FastAPI** missing frontend paths के लिए `index.html` serve नहीं करेगा। इसके बजाय यह `404.html` file लौटाएगा।
+
+/// tip | सुझाव
+
+Default रूप से, `fallback` की value `fallback="auto"` होती है। इसके साथ, अगर `404.html` file मिलती है, तो उसे अपने-आप fallback के रूप में उपयोग किया जाएगा।
+
+इसलिए, आप सामान्यतः `fallback` argument छोड़ सकते हैं।
+
+///
+
+यह उन frontend tools के साथ उपयोगी है जो हर page के लिए static HTML files generate करते हैं, जैसे Astro।
+
+## Fallback Auto { #fallback-auto }
+
+Default रूप से, `app.frontend()` `fallback="auto"` का उपयोग करता है।
+
+अगर frontend directory में `404.html` file है, तो missing frontend paths उस file को status code `404` के साथ serve करते हैं।
+
+अन्यथा, अगर `index.html` file है, तो missing browser navigation paths `index.html` serve करते हैं, जो client-side routing वाले कई frontend apps अपेक्षा करते हैं।
+
+इसलिए, अधिकतर मामलों में आप `fallback` argument specify किए बिना `app.frontend("/", directory="dist")` का उपयोग कर सकते हैं।
+
+{* ../../docs_src/frontend/tutorial001_py310.py hl[5] *}
+
+## Fallback बंद करें { #disable-fallback }
+
+अगर आप missing frontend paths के लिए fallback file serve नहीं करना चाहते, तो `fallback=None` का उपयोग करें:
+
+{* ../../docs_src/frontend/tutorial005_py310.py hl[5] *}
+
+फिर missing frontend paths सामान्य `404` लौटाते हैं।
+
+## Directory जाँचें { #check-directory }
+
+Default रूप से, `app.frontend()` app बनाते समय जाँचता है कि directory मौजूद है।
+
+यह configuration errors को जल्दी पकड़ने में मदद करता है। उदाहरण के लिए, अगर frontend build output directory missing है, तो **FastAPI** startup पर error raise करेगा।
+
+अगर आपकी frontend files बाद में बनाई जाती हैं, उदाहरण के लिए app object बनने के बाद किसी अलग build step द्वारा, तो `check_dir=False` set करें:
+
+{* ../../docs_src/frontend/tutorial006_py310.py hl[5] *}
+
+`check_dir=False` के साथ, **FastAPI** app बनाते समय directory की जाँच नहीं करेगा। अगर configured directory किसी request को handle करते समय अभी भी missing है, तो **FastAPI** तब error raise करेगा।
+
+## इसे `APIRouter` के साथ उपयोग करें { #use-it-with-apirouter }
+
+आप frontend files को `APIRouter` में भी जोड़ सकते हैं और उसे prefix के साथ include कर सकते हैं:
+
+{* ../../docs_src/frontend/tutorial004_py310.py hl[6,7] *}
+
+इस उदाहरण में, frontend paths `/app` के अंतर्गत serve किए जाते हैं।
+
+App में कोई भी नियमित *path operations* अभी भी precedence लेंगे, अन्य routers में शामिल ones भी।
+
+## Dependencies और Middleware { #dependencies-and-middleware }
+
+Frontend responses सामान्य **FastAPI** application के अंदर run करती हैं, इसलिए HTTP middleware उन पर लागू होता है।
+
+App से, `APIRouter` से, और `include_router()` से dependencies भी frontend responses पर लागू होती हैं। यह cookie authentication या इसी तरह से frontend को protect करने के लिए उपयोगी हो सकता है।
+
+## केवल Static Build Output { #static-build-output-only }
+
+`app.frontend()` आपके frontend build द्वारा पहले से generate की गई files serve करता है।
+
+यह server-side rendering run नहीं करता। यह उन frontend frameworks के लिए है जो static files generate करते हैं, न कि उन frameworks के लिए जिन्हें हर request के लिए server पर dynamic rendering की ज़रूरत होती है।

docs/hi/docs/tutorial/handling-errors.md

@@ -0,0 +1,244 @@
+# Errors को हैंडल करना { #handling-errors }
+
+ऐसी कई स्थितियाँ होती हैं जिनमें आपको अपनी API का उपयोग कर रहे client को error report करना पड़ता है।
+
+यह client frontend वाला कोई browser, किसी और का code, कोई IoT device आदि हो सकता है।
+
+आपको client को यह बताने की ज़रूरत पड़ सकती है कि:
+
+* client के पास उस operation के लिए पर्याप्त privileges नहीं हैं।
+* client के पास उस resource का access नहीं है।
+* जिस item को client access करने की कोशिश कर रहा था, वह मौजूद नहीं है।
+* आदि।
+
+इन मामलों में, आप सामान्यतः **400** की range (400 से 499 तक) में एक **HTTP status code** return करेंगे।
+
+यह 200 HTTP status codes (200 से 299 तक) जैसा ही है। वे "200" status codes का मतलब है कि request में किसी तरह "success" हुआ था।
+
+400 range के status codes का मतलब है कि client की तरफ़ से कोई error था।
+
+वे सभी **"404 Not Found"** errors (और jokes) याद हैं?
+
+## `HTTPException` का उपयोग करें { #use-httpexception }
+
+Client को errors वाली HTTP responses return करने के लिए आप `HTTPException` का उपयोग करते हैं।
+
+### `HTTPException` import करें { #import-httpexception }
+
+{* ../../docs_src/handling_errors/tutorial001_py310.py hl[1] *}
+
+### अपने code में `HTTPException` raise करें { #raise-an-httpexception-in-your-code }
+
+`HTTPException` APIs के लिए प्रासंगिक अतिरिक्त data के साथ एक सामान्य Python exception है।
+
+क्योंकि यह एक Python exception है, आप इसे `return` नहीं करते, आप इसे `raise` करते हैं।
+
+इसका यह भी मतलब है कि अगर आप किसी utility function के अंदर हैं जिसे आप अपनी *path operation function* के अंदर call कर रहे हैं, और आप उस utility function के अंदर से `HTTPException` raise करते हैं, तो यह *path operation function* में बाकी code नहीं चलाएगा, यह उस request को तुरंत समाप्त कर देगा और `HTTPException` से HTTP error client को भेज देगा।
+
+किसी value को return करने के बजाय exception raise करने का लाभ Dependencies और Security वाले section में अधिक स्पष्ट होगा।
+
+इस example में, जब client किसी ऐसे ID से item request करता है जो मौजूद नहीं है, तो `404` के status code के साथ exception raise करें:
+
+{* ../../docs_src/handling_errors/tutorial001_py310.py hl[11] *}
+
+### परिणामी response { #the-resulting-response }
+
+अगर client `http://example.com/items/foo` (एक `item_id` `"foo"`) request करता है, तो उस client को 200 का HTTP status code और यह JSON response मिलेगा:
+
+```JSON
+{
+  "item": "The Foo Wrestlers"
+}
+```
+
+लेकिन अगर client `http://example.com/items/bar` (एक non-existent `item_id` `"bar"`) request करता है, तो उस client को 404 का HTTP status code ("not found" error) और यह JSON response मिलेगा:
+
+```JSON
+{
+  "detail": "Item not found"
+}
+```
+
+/// tip | सुझाव
+
+`HTTPException` raise करते समय, आप `detail` parameter के रूप में ऐसी कोई भी value pass कर सकते हैं जिसे JSON में convert किया जा सकता हो, केवल `str` ही नहीं।
+
+आप `dict`, `list` आदि pass कर सकते हैं।
+
+इन्हें **FastAPI** अपने आप handle करता है और JSON में convert करता है।
+
+///
+
+## custom headers जोड़ें { #add-custom-headers }
+
+कुछ स्थितियाँ ऐसी होती हैं जहाँ HTTP error में custom headers जोड़ पाना उपयोगी होता है। उदाहरण के लिए, कुछ प्रकार की security के लिए।
+
+आपको शायद अपने code में सीधे इसका उपयोग करने की ज़रूरत नहीं होगी।
+
+लेकिन अगर किसी advanced scenario में आपको इसकी ज़रूरत पड़े, तो आप custom headers जोड़ सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial002_py310.py hl[14] *}
+
+## custom exception handlers install करें { #install-custom-exception-handlers }
+
+आप [Starlette से वही exception utilities](https://www.starlette.dev/exceptions/) के साथ custom exception handlers जोड़ सकते हैं।
+
+मान लीजिए आपके पास एक custom exception `UnicornException` है जिसे आप (या कोई library जिसका आप उपयोग करते हैं) `raise` कर सकते हैं।
+
+और आप इस exception को FastAPI के साथ globally handle करना चाहते हैं।
+
+आप `@app.exception_handler()` के साथ custom exception handler जोड़ सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial003_py310.py hl[5:7,13:18,24] *}
+
+यहाँ, अगर आप `/unicorns/yolo` request करते हैं, तो *path operation* एक `UnicornException` `raise` करेगा।
+
+लेकिन इसे `unicorn_exception_handler` द्वारा handle किया जाएगा।
+
+इसलिए, आपको `418` के HTTP status code और इस JSON content के साथ एक साफ़ error मिलेगा:
+
+```JSON
+{"message": "Oops! yolo did something. There goes a rainbow..."}
+```
+
+/// note | Technical Details
+
+आप `from starlette.requests import Request` और `from starlette.responses import JSONResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी, developer की, सुविधा के लिए `starlette.responses` को `fastapi.responses` के रूप में उपलब्ध कराता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं। `Request` के साथ भी यही है।
+
+///
+
+## default exception handlers को override करें { #override-the-default-exception-handlers }
+
+**FastAPI** में कुछ default exception handlers होते हैं।
+
+ये handlers default JSON responses return करने के लिए ज़िम्मेदार होते हैं, जब आप `HTTPException` `raise` करते हैं और जब request में invalid data होता है।
+
+आप इन exception handlers को अपने खुद के handlers से override कर सकते हैं।
+
+### request validation exceptions को override करें { #override-request-validation-exceptions }
+
+जब किसी request में invalid data होता है, तो **FastAPI** internally एक `RequestValidationError` raise करता है।
+
+और इसमें इसके लिए एक default exception handler भी शामिल होता है।
+
+इसे override करने के लिए, `RequestValidationError` import करें और exception handler को decorate करने के लिए इसे `@app.exception_handler(RequestValidationError)` के साथ उपयोग करें।
+
+Exception handler को एक `Request` और exception मिलेगा।
+
+{* ../../docs_src/handling_errors/tutorial004_py310.py hl[2,14:19] *}
+
+अब, अगर आप `/items/foo` पर जाते हैं, तो default JSON error पाने के बजाय:
+
+```JSON
+{
+    "detail": [
+        {
+            "loc": [
+                "path",
+                "item_id"
+            ],
+            "msg": "value is not a valid integer",
+            "type": "type_error.integer"
+        }
+    ]
+}
+```
+
+आपको text version मिलेगा, जिसमें होगा:
+
+```
+Validation errors:
+Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
+```
+
+### `HTTPException` error handler को override करें { #override-the-httpexception-error-handler }
+
+उसी तरह, आप `HTTPException` handler को override कर सकते हैं।
+
+उदाहरण के लिए, आप इन errors के लिए JSON के बजाय plain text response return करना चाह सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial004_py310.py hl[3:4,9:11,25] *}
+
+/// note | Technical Details
+
+आप `from starlette.responses import PlainTextResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी, developer की, सुविधा के लिए `starlette.responses` को `fastapi.responses` के रूप में उपलब्ध कराता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+///
+
+/// warning | चेतावनी
+
+ध्यान रखें कि `RequestValidationError` में file name और उस line की जानकारी होती है जहाँ validation error होता है, ताकि अगर आप चाहें तो relevant जानकारी के साथ उसे अपने logs में दिखा सकें।
+
+लेकिन इसका मतलब है कि अगर आप इसे केवल string में convert करके वह जानकारी सीधे return कर देते हैं, तो आप अपने system के बारे में थोड़ी जानकारी leak कर सकते हैं, इसलिए यहाँ code हर error को अलग-अलग extract करके दिखाता है।
+
+///
+
+### `RequestValidationError` body का उपयोग करें { #use-the-requestvalidationerror-body }
+
+`RequestValidationError` में वह `body` होता है जो इसे invalid data के साथ मिला था।
+
+आप अपनी app develop करते समय body को log और debug करने, user को return करने आदि के लिए इसका उपयोग कर सकते हैं।
+
+{* ../../docs_src/handling_errors/tutorial005_py310.py hl[14] *}
+
+अब ऐसा invalid item भेजकर देखें:
+
+```JSON
+{
+  "title": "towel",
+  "size": "XL"
+}
+```
+
+आपको एक response मिलेगा जो बताता है कि data invalid है और जिसमें received body शामिल होगा:
+
+```JSON hl_lines="12-15"
+{
+  "detail": [
+    {
+      "loc": [
+        "body",
+        "size"
+      ],
+      "msg": "value is not a valid integer",
+      "type": "type_error.integer"
+    }
+  ],
+  "body": {
+    "title": "towel",
+    "size": "XL"
+  }
+}
+```
+
+#### FastAPI का `HTTPException` बनाम Starlette का `HTTPException` { #fastapis-httpexception-vs-starlettes-httpexception }
+
+**FastAPI** का अपना `HTTPException` है।
+
+और **FastAPI** की `HTTPException` error class, Starlette की `HTTPException` error class से inherit करती है।
+
+केवल अंतर यह है कि **FastAPI** का `HTTPException`, `detail` field के लिए कोई भी JSON-able data accept करता है, जबकि Starlette का `HTTPException` इसके लिए केवल strings accept करता है।
+
+इसलिए, आप अपने code में सामान्य रूप से **FastAPI** का `HTTPException` raise करते रह सकते हैं।
+
+लेकिन जब आप exception handler register करते हैं, तो आपको उसे Starlette के `HTTPException` के लिए register करना चाहिए।
+
+इस तरह, अगर Starlette के internal code का कोई हिस्सा, या कोई Starlette extension या plug-in, Starlette `HTTPException` raise करता है, तो आपका handler उसे catch और handle कर पाएगा।
+
+इस example में, एक ही code में दोनों `HTTPException`s रखने के लिए, Starlette के exceptions को `StarletteHTTPException` नाम दिया गया है:
+
+```Python
+from starlette.exceptions import HTTPException as StarletteHTTPException
+```
+
+### **FastAPI** के exception handlers का फिर से उपयोग करें { #reuse-fastapis-exception-handlers }
+
+अगर आप **FastAPI** के उन्हीं default exception handlers के साथ exception का उपयोग करना चाहते हैं, तो आप `fastapi.exception_handlers` से default exception handlers import करके उनका फिर से उपयोग कर सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial006_py310.py hl[2:5,15,21] *}
+
+इस example में आप केवल error को बहुत expressive message के साथ print कर रहे हैं, लेकिन आप बात समझ गए। आप exception का उपयोग कर सकते हैं और फिर बस default exception handlers का फिर से उपयोग कर सकते हैं।

docs/hi/docs/tutorial/header-param-models.md

@@ -0,0 +1,72 @@
+# Header Parameter Models { #header-parameter-models }
+
+अगर आपके पास संबंधित **header parameters** का एक समूह है, तो आप उन्हें declare करने के लिए एक **Pydantic model** बना सकते हैं।
+
+इससे आप **model को फिर से उपयोग** कर पाएंगे, **कई जगहों** पर, और साथ ही सभी parameters के लिए validations और metadata एक साथ declare कर पाएंगे। 😎
+
+/// note | नोट
+
+यह FastAPI version `0.115.0` से समर्थित है। 🤓
+
+///
+
+## Pydantic Model के साथ Header Parameters { #header-parameters-with-a-pydantic-model }
+
+जिन **header parameters** की आपको ज़रूरत है, उन्हें एक **Pydantic model** में declare करें, और फिर parameter को `Header` के रूप में declare करें:
+
+{* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *}
+
+**FastAPI** request में **headers** से **हर field** का data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs देखें { #check-the-docs }
+
+आप `/docs` पर docs UI में required headers देख सकते हैं:
+
+<div class="screenshot">
+<img src="/img/tutorial/header-param-models/image01.png">
+</div>
+
+## Extra Headers को मना करें { #forbid-extra-headers }
+
+कुछ विशेष use cases में (शायद बहुत आम नहीं), आप उन headers को **restrict** करना चाह सकते हैं जिन्हें आप receive करना चाहते हैं।
+
+आप Pydantic की model configuration का उपयोग करके किसी भी `extra` fields को `forbid` कर सकते हैं:
+
+{* ../../docs_src/header_param_models/tutorial002_an_py310.py hl[10] *}
+
+अगर कोई client कुछ **extra headers** भेजने की कोशिश करता है, तो उन्हें एक **error** response मिलेगा।
+
+उदाहरण के लिए, अगर client `plumbus` के value के साथ एक `tool` header भेजने की कोशिश करता है, तो उन्हें एक **error** response मिलेगा जो बताएगा कि header parameter `tool` की अनुमति नहीं है:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["header", "tool"],
+            "msg": "Extra inputs are not permitted",
+            "input": "plumbus",
+        }
+    ]
+}
+```
+
+## Convert Underscores को Disable करें { #disable-convert-underscores }
+
+नियमित header parameters की तरह ही, जब parameter names में underscore characters होते हैं, तो वे **स्वचालित रूप से hyphens में convert** हो जाते हैं।
+
+उदाहरण के लिए, अगर आपके code में header parameter `save_data` है, तो अपेक्षित HTTP header `save-data` होगा, और docs में भी वह इसी तरह दिखाई देगा।
+
+अगर किसी कारण से आपको इस automatic conversion को disable करना है, तो आप header parameters के लिए Pydantic models में भी ऐसा कर सकते हैं।
+
+{* ../../docs_src/header_param_models/tutorial003_an_py310.py hl[19] *}
+
+/// warning | चेतावनी
+
+`convert_underscores` को `False` पर set करने से पहले, ध्यान रखें कि कुछ HTTP proxies और servers underscores वाले headers के उपयोग की अनुमति नहीं देते।
+
+///
+
+## सारांश { #summary }
+
+आप **FastAPI** में **headers** declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/header-params.md

@@ -0,0 +1,91 @@
+# Header Parameters { #header-parameters }
+
+आप Header parameters को उसी तरह define कर सकते हैं जैसे आप `Query`, `Path` और `Cookie` parameters को define करते हैं।
+
+## `Header` import करें { #import-header }
+
+पहले `Header` import करें:
+
+{* ../../docs_src/header_params/tutorial001_an_py310.py hl[3] *}
+
+## `Header` parameters घोषित करें { #declare-header-parameters }
+
+फिर `Path`, `Query` और `Cookie` जैसी ही structure का उपयोग करके header parameters घोषित करें।
+
+आप default value के साथ-साथ सभी अतिरिक्त validation या annotation parameters भी define कर सकते हैं:
+
+{* ../../docs_src/header_params/tutorial001_an_py310.py hl[9] *}
+
+/// note | तकनीकी विवरण
+
+`Header` `Path`, `Query` और `Cookie` की एक "sister" class है। यह भी उसी common `Param` class से inherit करता है।
+
+लेकिन याद रखें कि जब आप `fastapi` से `Query`, `Path`, `Header`, और अन्य import करते हैं, तो वे वास्तव में functions होते हैं जो special classes return करते हैं।
+
+///
+
+/// note | नोट
+
+headers घोषित करने के लिए, आपको `Header` का उपयोग करना होगा, क्योंकि अन्यथा parameters को query parameters के रूप में interpret किया जाएगा।
+
+///
+
+## स्वचालित conversion { #automatic-conversion }
+
+`Header` में `Path`, `Query` और `Cookie` द्वारा दी जाने वाली functionality के ऊपर थोड़ी अतिरिक्त functionality होती है।
+
+अधिकांश standard headers एक "hyphen" character से अलग किए जाते हैं, जिसे "minus symbol" (`-`) भी कहा जाता है।
+
+लेकिन Python में `user-agent` जैसा variable invalid है।
+
+इसलिए, default रूप से, `Header` headers को extract और document करने के लिए parameter names के characters को underscore (`_`) से hyphen (`-`) में convert करेगा।
+
+साथ ही, HTTP headers case-insensitive होते हैं, इसलिए, आप उन्हें standard Python style (जिसे "snake_case" भी कहा जाता है) में declare कर सकते हैं।
+
+इसलिए, Python code में सामान्य रूप से जैसे आप `user_agent` का उपयोग करते हैं, वैसा ही कर सकते हैं, बजाय इसके कि आपको पहले अक्षरों को `User_Agent` की तरह capitalize करना पड़े या कुछ समान करना पड़े।
+
+अगर किसी कारण से आपको underscores से hyphens में automatic conversion disable करना हो, तो `Header` के parameter `convert_underscores` को `False` पर set करें:
+
+{* ../../docs_src/header_params/tutorial002_an_py310.py hl[10] *}
+
+/// warning | चेतावनी
+
+`convert_underscores` को `False` पर set करने से पहले, ध्यान रखें कि कुछ HTTP proxies और servers underscores वाले headers के उपयोग की अनुमति नहीं देते।
+
+///
+
+## Duplicate headers { #duplicate-headers }
+
+duplicate headers receive करना संभव है। इसका मतलब है, कई values वाला वही header।
+
+आप type declaration में list का उपयोग करके ऐसे cases define कर सकते हैं।
+
+आप duplicate header से सभी values Python `list` के रूप में receive करेंगे।
+
+उदाहरण के लिए, `X-Token` का header declare करने के लिए जो एक से अधिक बार आ सकता है, आप लिख सकते हैं:
+
+{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}
+
+यदि आप उस *path operation* के साथ दो HTTP headers भेजते हुए communicate करते हैं, जैसे:
+
+```
+X-Token: foo
+X-Token: bar
+```
+
+response ऐसा होगा:
+
+```JSON
+{
+    "X-Token values": [
+        "bar",
+        "foo"
+    ]
+}
+```
+
+## Recap { #recap }
+
+`Query`, `Path` और `Cookie` जैसे ही common pattern का उपयोग करते हुए, `Header` के साथ headers declare करें।
+
+और अपनी variables में underscores के बारे में चिंता न करें, **FastAPI** उन्हें convert करने का ध्यान रखेगा।

docs/hi/docs/tutorial/index.md

@@ -0,0 +1,101 @@
+# Tutorial - उपयोगकर्ता गाइड { #tutorial-user-guide }
+
+यह tutorial आपको step by step दिखाता है कि **FastAPI** को इसकी अधिकतर features के साथ कैसे उपयोग करें।
+
+हर section धीरे-धीरे पिछले section पर आधारित होता है, लेकिन इसे topics को अलग रखने के लिए संरचित किया गया है, ताकि आप अपनी खास API ज़रूरतों को हल करने के लिए सीधे किसी भी specific topic पर जा सकें।
+
+इसे भविष्य के reference के रूप में काम करने के लिए भी बनाया गया है, ताकि आप वापस आकर ठीक वही देख सकें जिसकी आपको ज़रूरत है।
+
+## code चलाएँ { #run-the-code }
+
+सभी code blocks को copy करके सीधे उपयोग किया जा सकता है (वे वास्तव में tested Python files हैं)।
+
+किसी भी example को चलाने के लिए, code को `main.py` file में copy करें, और `fastapi dev` शुरू करें:
+
+<div class="termy">
+
+```console
+$ <font color="#4E9A06">fastapi</font> dev
+
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
+
+             Searching for package file structure from directories
+             with <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
+             the following code:
+
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
+             to quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+```
+
+</div>
+
+यह **बहुत ज़्यादा प्रोत्साहित** किया जाता है कि आप code लिखें या copy करें, उसे edit करें और locally चलाएँ।
+
+इसे अपने editor में उपयोग करना ही वास्तव में आपको FastAPI के लाभ दिखाता है, जैसे आपको कितना कम code लिखना पड़ता है, सभी type checks, autocompletion, आदि।
+
+---
+
+## FastAPI install करें { #install-fastapi }
+
+पहला step FastAPI install करना है।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर **FastAPI install करें**:
+
+<div class="termy">
+
+```console
+$ pip install "fastapi[standard]"
+
+---> 100%
+```
+
+</div>
+
+/// note | नोट
+
+जब आप `pip install "fastapi[standard]"` के साथ install करते हैं, तो यह कुछ default optional standard dependencies के साथ आता है, जिनमें `fastapi-cloud-cli` शामिल है, जो आपको [FastAPI Cloud](https://fastapicloud.com) पर deploy करने देता है।
+
+अगर आप वे optional dependencies नहीं चाहते, तो इसके बजाय आप `pip install fastapi` install कर सकते हैं।
+
+अगर आप standard dependencies install करना चाहते हैं लेकिन `fastapi-cloud-cli` के बिना, तो आप `pip install "fastapi[standard-no-fastapi-cloud-cli]"` के साथ install कर सकते हैं।
+
+///
+
+/// tip | सुझाव
+
+FastAPI के पास [VS Code के लिए official extension](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (और Cursor) है, जो बहुत सारी features देता है, जिनमें path operation explorer, path operation search, tests में CodeLens navigation (tests से definition पर jump करना), और FastAPI Cloud deployment और logs शामिल हैं — सब कुछ आपके editor से।
+
+///
+
+## उन्नत उपयोगकर्ता गाइड { #advanced-user-guide }
+
+एक **उन्नत उपयोगकर्ता गाइड** भी है जिसे आप इस **Tutorial - उपयोगकर्ता गाइड** के बाद पढ़ सकते हैं।
+
+**उन्नत उपयोगकर्ता गाइड** इसी पर आधारित है, वही concepts उपयोग करता है, और आपको कुछ अतिरिक्त features सिखाता है।
+
+लेकिन आपको पहले **Tutorial - उपयोगकर्ता गाइड** पढ़ना चाहिए (जो आप अभी पढ़ रहे हैं)।
+
+इसे इस तरह design किया गया है कि आप सिर्फ **Tutorial - उपयोगकर्ता गाइड** के साथ एक complete application बना सकें, और फिर अपनी ज़रूरतों के अनुसार **उन्नत उपयोगकर्ता गाइड** के कुछ अतिरिक्त ideas का उपयोग करके उसे अलग-अलग तरीकों से extend कर सकें।

docs/hi/docs/tutorial/metadata.md

@@ -0,0 +1,120 @@
+# Metadata और Docs URLs { #metadata-and-docs-urls }
+
+आप अपनी **FastAPI** application में कई metadata configurations को customize कर सकते हैं।
+
+## API के लिए Metadata { #metadata-for-api }
+
+आप निम्नलिखित fields set कर सकते हैं, जिनका उपयोग OpenAPI specification और automatic API docs UIs में किया जाता है:
+
+| Parameter | Type | विवरण |
+|------------|------|-------------|
+| `title` | `str` | API का title। |
+| `summary` | `str` | API का एक छोटा summary। <small>OpenAPI 3.1.0, FastAPI 0.99.0 से उपलब्ध।</small> |
+| `description` | `str` | API का एक छोटा description। यह Markdown का उपयोग कर सकता है। |
+| `version` | `str` | API का version। यह आपकी अपनी application का version है, OpenAPI का नहीं। उदाहरण के लिए `2.5.0`। |
+| `terms_of_service` | `str` | API के Terms of Service के लिए एक URL। यदि दिया गया हो, तो यह URL होना चाहिए। |
+| `contact` | `dict` | exposed API के लिए contact information। इसमें कई fields हो सकते हैं। <details><summary><code>contact</code> fields</summary><table><thead><tr><th>Parameter</th><th>Type</th><th>विवरण</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>contact person/organization का identifying name।</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>contact information की ओर point करने वाला URL। URL के format में होना चाहिए।</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>contact person/organization का email address। email address के format में होना चाहिए।</td></tr></tbody></table></details> |
+| `license_info` | `dict` | exposed API के लिए license information। इसमें कई fields हो सकते हैं। <details><summary><code>license_info</code> fields</summary><table><thead><tr><th>Parameter</th><th>Type</th><th>विवरण</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>REQUIRED</strong> (यदि <code>license_info</code> set किया गया हो)। API के लिए उपयोग किया गया license name।</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>API के लिए एक [SPDX](https://spdx.org/licenses/) license expression। <code>identifier</code> field, <code>url</code> field के साथ mutually exclusive है। <small>OpenAPI 3.1.0, FastAPI 0.99.0 से उपलब्ध।</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>API के लिए उपयोग किए गए license का URL। URL के format में होना चाहिए।</td></tr></tbody></table></details> |
+
+आप इन्हें इस तरह set कर सकते हैं:
+
+{* ../../docs_src/metadata/tutorial001_py310.py hl[3:16, 19:32] *}
+
+/// tip | सुझाव
+
+आप `description` field में Markdown लिख सकते हैं और यह output में render होगा।
+
+///
+
+इस configuration के साथ, automatic API docs इस तरह दिखेंगे:
+
+<img src="/img/tutorial/metadata/image01.png">
+
+## License identifier { #license-identifier }
+
+OpenAPI 3.1.0 और FastAPI 0.99.0 से, आप `license_info` को `url` के बजाय `identifier` के साथ भी set कर सकते हैं।
+
+उदाहरण के लिए:
+
+{* ../../docs_src/metadata/tutorial001_1_py310.py hl[31] *}
+
+## Tags के लिए Metadata { #metadata-for-tags }
+
+आप अपने path operations को group करने के लिए उपयोग किए गए अलग-अलग tags के लिए `openapi_tags` parameter के साथ अतिरिक्त metadata भी जोड़ सकते हैं।
+
+यह प्रत्येक tag के लिए एक dictionary वाली list लेता है।
+
+प्रत्येक dictionary में हो सकता है:
+
+* `name` (**required**): वही tag name वाला `str`, जिसे आप अपने *path operations* और `APIRouter`s में `tags` parameter में उपयोग करते हैं।
+* `description`: tag के लिए short description वाला `str`। इसमें Markdown हो सकता है और यह docs UI में दिखाया जाएगा।
+* `externalDocs`: external documentation का वर्णन करने वाला `dict`, जिसमें:
+    * `description`: external docs के लिए short description वाला `str`।
+    * `url` (**required**): external documentation के लिए URL वाला `str`।
+
+### Tags के लिए metadata बनाएँ { #create-metadata-for-tags }
+
+आइए इसे `users` और `items` के tags वाले एक उदाहरण में आज़माते हैं।
+
+अपने tags के लिए metadata बनाएँ और उसे `openapi_tags` parameter में pass करें:
+
+{* ../../docs_src/metadata/tutorial004_py310.py hl[3:16,18] *}
+
+ध्यान दें कि आप descriptions के अंदर Markdown का उपयोग कर सकते हैं, उदाहरण के लिए "login" bold (**login**) में दिखेगा और "fancy" italics (_fancy_) में दिखेगा।
+
+/// tip | सुझाव
+
+आपको अपने उपयोग किए गए सभी tags के लिए metadata जोड़ना ज़रूरी नहीं है।
+
+///
+
+### अपने tags का उपयोग करें { #use-your-tags }
+
+अपने *path operations* (और `APIRouter`s) के साथ `tags` parameter का उपयोग करें, ताकि उन्हें अलग-अलग tags में assign किया जा सके:
+
+{* ../../docs_src/metadata/tutorial004_py310.py hl[21,26] *}
+
+/// note | नोट
+
+Tags के बारे में और पढ़ें [Path Operation Configuration](path-operation-configuration.md#tags) में।
+
+///
+
+### Docs जाँचें { #check-the-docs }
+
+अब, अगर आप docs जाँचते हैं, तो वे सभी अतिरिक्त metadata दिखाएँगे:
+
+<img src="/img/tutorial/metadata/image02.png">
+
+### Tags का क्रम { #order-of-tags }
+
+हर tag metadata dictionary का क्रम भी docs UI में दिखाए जाने वाले क्रम को define करता है।
+
+उदाहरण के लिए, भले ही `users` alphabetical order में `items` के बाद आता, यह उनसे पहले दिखाया जाता है, क्योंकि हमने उनकी metadata को list में पहली dictionary के रूप में जोड़ा था।
+
+## OpenAPI URL { #openapi-url }
+
+Default रूप से, OpenAPI schema `/openapi.json` पर serve किया जाता है।
+
+लेकिन आप इसे `openapi_url` parameter के साथ configure कर सकते हैं।
+
+उदाहरण के लिए, इसे `/api/v1/openapi.json` पर serve करने के लिए set करने हेतु:
+
+{* ../../docs_src/metadata/tutorial002_py310.py hl[3] *}
+
+यदि आप OpenAPI schema को पूरी तरह disable करना चाहते हैं, तो आप `openapi_url=None` set कर सकते हैं, इससे इसका उपयोग करने वाले documentation user interfaces भी disable हो जाएँगे।
+
+## Docs URLs { #docs-urls }
+
+आप शामिल किए गए दो documentation user interfaces configure कर सकते हैं:
+
+* **Swagger UI**: `/docs` पर serve किया जाता है।
+    * आप इसका URL `docs_url` parameter के साथ set कर सकते हैं।
+    * आप `docs_url=None` set करके इसे disable कर सकते हैं।
+* **ReDoc**: `/redoc` पर serve किया जाता है।
+    * आप इसका URL `redoc_url` parameter के साथ set कर सकते हैं।
+    * आप `redoc_url=None` set करके इसे disable कर सकते हैं।
+
+उदाहरण के लिए, Swagger UI को `/documentation` पर serve करने के लिए set करना और ReDoc को disable करना:
+
+{* ../../docs_src/metadata/tutorial003_py310.py hl[3] *}

docs/hi/docs/tutorial/middleware.md

@@ -0,0 +1,95 @@
+# Middleware { #middleware }
+
+आप **FastAPI** applications में middleware जोड़ सकते हैं।
+
+"middleware" एक function है जो हर **request** के साथ काम करता है, इससे पहले कि उसे किसी विशेष *path operation* द्वारा process किया जाए। और हर **response** के साथ भी, उसे लौटाने से पहले।
+
+* यह आपके application में आने वाली हर **request** लेता है।
+* फिर यह उस **request** के साथ कुछ कर सकता है या कोई required code चला सकता है।
+* फिर यह **request** को application के बाकी हिस्से द्वारा process होने के लिए आगे भेजता है (किसी *path operation* द्वारा)।
+* फिर यह application द्वारा generate किया गया **response** लेता है (किसी *path operation* द्वारा)।
+* यह उस **response** के साथ कुछ कर सकता है या कोई required code चला सकता है।
+* फिर यह **response** लौटाता है।
+
+/// note | तकनीकी विवरण
+
+अगर आपके पास `yield` वाली dependencies हैं, तो exit code middleware के *बाद* चलेगा।
+
+अगर कोई background tasks थे ([Background Tasks](background-tasks.md) section में कवर किया गया है, आप इसे बाद में देखेंगे), तो वे सभी middleware के *बाद* चलेंगे।
+
+///
+
+## Middleware बनाएं { #create-a-middleware }
+
+middleware बनाने के लिए आप किसी function के ऊपर decorator `@app.middleware("http")` का उपयोग करते हैं।
+
+middleware function को मिलता है:
+
+* `request`।
+* एक function `call_next` जो `request` को parameter के रूप में प्राप्त करेगा।
+    * यह function `request` को संबंधित *path operation* तक पास करेगा।
+    * फिर यह संबंधित *path operation* द्वारा generate किया गया `response` लौटाता है।
+* फिर आप `response` लौटाने से पहले उसे और modify कर सकते हैं।
+
+{* ../../docs_src/middleware/tutorial001_py310.py hl[8:9,11,14] *}
+
+/// tip | सुझाव
+
+ध्यान रखें कि custom proprietary headers को [`X-` prefix का उपयोग करके](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) जोड़ा जा सकता है।
+
+लेकिन अगर आपके पास custom headers हैं जिन्हें आप browser में client को दिखाना चाहते हैं, तो आपको उन्हें अपने CORS configurations ([CORS (Cross-Origin Resource Sharing)](cors.md)) में `expose_headers` parameter का उपयोग करके जोड़ना होगा, जैसा कि [Starlette के CORS docs](https://www.starlette.dev/middleware/#corsmiddleware) में documented है।
+
+///
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.requests import Request` भी उपयोग कर सकते हैं।
+
+**FastAPI** इसे आपके लिए, developer की सुविधा के रूप में provide करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+### `response` से पहले और बाद में { #before-and-after-the-response }
+
+आप `request` के साथ चलाने के लिए code जोड़ सकते हैं, इससे पहले कि कोई *path operation* उसे प्राप्त करे।
+
+और `response` generate होने के बाद भी, उसे लौटाने से पहले।
+
+उदाहरण के लिए, आप एक custom header `X-Process-Time` जोड़ सकते हैं जिसमें seconds में वह time हो जो request को process करने और response generate करने में लगा:
+
+{* ../../docs_src/middleware/tutorial001_py310.py hl[10,12:13] *}
+
+/// tip | सुझाव
+
+यहाँ हम `time.time()` के बजाय [`time.perf_counter()`](https://docs.python.org/3/library/time.html#time.perf_counter) का उपयोग करते हैं क्योंकि यह इन use cases के लिए अधिक precise हो सकता है। 🤓
+
+///
+
+## कई middleware का execution order { #multiple-middleware-execution-order }
+
+जब आप `@app.middleware()` decorator या `app.add_middleware()` method का उपयोग करके कई middleware जोड़ते हैं, तो हर नया middleware application को wrap करता है, जिससे एक stack बनता है। जो middleware अंत में जोड़ा जाता है वह *outermost* होता है, और पहला *innermost* होता है।
+
+request path पर, *outermost* middleware पहले चलता है।
+
+response path पर, यह अंत में चलता है।
+
+उदाहरण के लिए:
+
+```Python
+app.add_middleware(MiddlewareA)
+app.add_middleware(MiddlewareB)
+```
+
+इससे execution order यह होता है:
+
+* **Request**: MiddlewareB → MiddlewareA → route
+
+* **Response**: route → MiddlewareA → MiddlewareB
+
+यह stacking behavior सुनिश्चित करता है कि middleware एक predictable और controllable order में execute हों।
+
+## अन्य middleware { #other-middlewares }
+
+आप बाद में [Advanced User Guide: Advanced Middleware](../advanced/middleware.md) में अन्य middleware के बारे में और पढ़ सकते हैं।
+
+आप अगले section में middleware के साथ <abbr title="Cross-Origin Resource Sharing - क्रॉस-ओरिजिन रिसोर्स शेयरिंग">CORS</abbr> को handle करने के बारे में पढ़ेंगे।

docs/hi/docs/tutorial/path-operation-configuration.md

@@ -0,0 +1,107 @@
+# Path Operation Configuration { #path-operation-configuration }
+
+कई parameters हैं जिन्हें आप अपने *path operation decorator* को configure करने के लिए pass कर सकते हैं।
+
+/// warning | चेतावनी
+
+ध्यान दें कि ये parameters सीधे *path operation decorator* को pass किए जाते हैं, आपके *path operation function* को नहीं।
+
+///
+
+## Response Status Code { #response-status-code }
+
+आप अपनी *path operation* की response में उपयोग किए जाने वाला (HTTP) `status_code` define कर सकते हैं।
+
+आप सीधे `int` code pass कर सकते हैं, जैसे `404`।
+
+लेकिन अगर आपको याद नहीं है कि हर number code किसके लिए है, तो आप `status` में shortcut constants का उपयोग कर सकते हैं:
+
+{* ../../docs_src/path_operation_configuration/tutorial001_py310.py hl[1,15] *}
+
+वह status code response में उपयोग किया जाएगा और OpenAPI schema में जोड़ा जाएगा।
+
+/// note | तकनीकी विवरण
+
+आप `from starlette import status` भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.status` `fastapi.status` के रूप में प्रदान करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+## Tags { #tags }
+
+आप अपनी *path operation* में tags जोड़ सकते हैं, parameter `tags` को `str` की `list` के साथ pass करें (आम तौर पर सिर्फ एक `str`):
+
+{* ../../docs_src/path_operation_configuration/tutorial002_py310.py hl[15,20,25] *}
+
+वे OpenAPI schema में जोड़े जाएंगे और automatic documentation interfaces द्वारा उपयोग किए जाएंगे:
+
+<img src="/img/tutorial/path-operation-configuration/image01.png">
+
+### Enums के साथ Tags { #tags-with-enums }
+
+अगर आपके पास एक बड़ी application है, तो आप अंत में **कई tags** जमा कर सकते हैं, और आप यह सुनिश्चित करना चाहेंगे कि related *path operations* के लिए आप हमेशा **एक ही tag** का उपयोग करें।
+
+इन मामलों में, tags को एक `Enum` में store करना समझदारी हो सकती है।
+
+**FastAPI** इसे plain strings की तरह ही support करता है:
+
+{* ../../docs_src/path_operation_configuration/tutorial002b_py310.py hl[1,8:10,13,18] *}
+
+## Summary और description { #summary-and-description }
+
+आप `summary` और `description` जोड़ सकते हैं:
+
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+
+## Docstring से description { #description-from-docstring }
+
+क्योंकि descriptions आम तौर पर लंबी होती हैं और कई lines में फैलती हैं, आप *path operation* की description को function <dfn title="documentation के लिए उपयोग की जाने वाली function के अंदर पहली expression के रूप में multi-line string (जो किसी भी variable को assign नहीं की गई होती)">docstring</dfn> में declare कर सकते हैं और **FastAPI** उसे वहीं से पढ़ेगा।
+
+आप docstring में [Markdown](https://en.wikipedia.org/wiki/Markdown) लिख सकते हैं, इसे सही तरीके से interpret और display किया जाएगा (docstring indentation को ध्यान में रखते हुए)।
+
+{* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
+
+इसे interactive docs में उपयोग किया जाएगा:
+
+<img src="/img/tutorial/path-operation-configuration/image02.png">
+
+## Response description { #response-description }
+
+आप parameter `response_description` के साथ response description specify कर सकते हैं:
+
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+
+/// note | नोट
+
+ध्यान दें कि `response_description` विशेष रूप से response को refer करता है, जबकि `description` सामान्य रूप से *path operation* को refer करता है।
+
+///
+
+/// tip | सुझाव
+
+OpenAPI specify करता है कि प्रत्येक *path operation* को response description required होती है।
+
+इसलिए, अगर आप कोई provide नहीं करते, तो **FastAPI** अपने आप "Successful response" generate कर देगा।
+
+///
+
+<img src="/img/tutorial/path-operation-configuration/image03.png">
+
+## एक *path operation* को Deprecated करें { #deprecate-a-path-operation }
+
+अगर आपको किसी *path operation* को <dfn title="पुराना, इसका उपयोग न करने की सलाह दी जाती है">deprecated</dfn> के रूप में mark करना है, लेकिन उसे हटाना नहीं है, तो parameter `deprecated` pass करें:
+
+{* ../../docs_src/path_operation_configuration/tutorial006_py310.py hl[16] *}
+
+इसे interactive docs में स्पष्ट रूप से deprecated के रूप में mark किया जाएगा:
+
+<img src="/img/tutorial/path-operation-configuration/image04.png">
+
+देखें कि deprecated और non-deprecated *path operations* कैसे दिखते हैं:
+
+<img src="/img/tutorial/path-operation-configuration/image05.png">
+
+## Recap { #recap }
+
+आप *path operation decorators* को parameters pass करके अपनी *path operations* के लिए metadata आसानी से configure और add कर सकते हैं।

docs/hi/docs/tutorial/path-params-numeric-validations.md

@@ -0,0 +1,154 @@
+# Path Parameters और संख्यात्मक Validations { #path-parameters-and-numeric-validations }
+
+जिस तरह आप `Query` के साथ query parameters के लिए अधिक validations और metadata घोषित कर सकते हैं, उसी तरह आप `Path` के साथ path parameters के लिए उसी प्रकार की validations और metadata घोषित कर सकते हैं।
+
+## `Path` import करें { #import-path }
+
+सबसे पहले, `fastapi` से `Path` import करें, और `Annotated` import करें:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[1,3] *}
+
+/// note | नोट
+
+FastAPI ने version 0.95.0 में `Annotated` के लिए support जोड़ा था (और इसकी सिफारिश करना शुरू किया था)।
+
+अगर आपके पास पुराना version है, तो `Annotated` का उपयोग करने की कोशिश करते समय आपको errors मिलेंगे।
+
+`Annotated` का उपयोग करने से पहले सुनिश्चित करें कि आप [FastAPI version को Upgrade करें](../deployment/versions.md#upgrading-the-fastapi-versions) कम से कम 0.95.1 तक।
+
+///
+
+## Metadata घोषित करें { #declare-metadata }
+
+आप `Query` के लिए जैसे सभी parameters घोषित करते हैं, वैसे ही यहाँ भी कर सकते हैं।
+
+उदाहरण के लिए, path parameter `item_id` के लिए `title` metadata value घोषित करने के लिए आप लिख सकते हैं:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
+
+/// note | नोट
+
+एक path parameter हमेशा required होता है क्योंकि उसे path का हिस्सा होना होता है। भले ही आपने इसे `None` के साथ घोषित किया हो या कोई default value सेट की हो, इससे कुछ भी प्रभावित नहीं होगा, यह फिर भी हमेशा required रहेगा।
+
+///
+
+## Parameters को अपनी ज़रूरत के अनुसार क्रम दें { #order-the-parameters-as-you-need }
+
+/// tip | सुझाव
+
+यदि आप `Annotated` का उपयोग करते हैं, तो यह शायद उतना महत्वपूर्ण या ज़रूरी नहीं है।
+
+///
+
+मान लें कि आप query parameter `q` को required `str` के रूप में घोषित करना चाहते हैं।
+
+और आपको उस parameter के लिए कुछ और घोषित करने की ज़रूरत नहीं है, इसलिए वास्तव में आपको `Query` का उपयोग करने की ज़रूरत नहीं है।
+
+लेकिन आपको फिर भी `item_id` path parameter के लिए `Path` का उपयोग करना होगा। और किसी कारण से आप `Annotated` का उपयोग नहीं करना चाहते।
+
+यदि आप किसी ऐसे value को, जिसके पास "default" है, ऐसे value से पहले रखते हैं जिसके पास "default" नहीं है, तो Python शिकायत करेगा।
+
+लेकिन आप उनका क्रम बदल सकते हैं, और बिना default वाले value (query parameter `q`) को पहले रख सकते हैं।
+
+**FastAPI** के लिए इससे फर्क नहीं पड़ता। यह parameters को उनके नामों, types और default declarations (`Query`, `Path`, आदि) से पहचान लेगा, इसे क्रम से कोई फर्क नहीं पड़ता।
+
+तो, आप अपनी function इस तरह घोषित कर सकते हैं:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial002_py310.py hl[7] *}
+
+लेकिन ध्यान रखें कि यदि आप `Annotated` का उपयोग करते हैं, तो आपको यह समस्या नहीं होगी, क्योंकि आप `Query()` या `Path()` के लिए function parameter default values का उपयोग नहीं कर रहे हैं।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py310.py *}
+
+## Parameters को अपनी ज़रूरत के अनुसार क्रम दें, tricks { #order-the-parameters-as-you-need-tricks }
+
+/// tip | सुझाव
+
+यदि आप `Annotated` का उपयोग करते हैं, तो यह शायद उतना महत्वपूर्ण या ज़रूरी नहीं है।
+
+///
+
+यहाँ एक **छोटी trick** है जो काम आ सकती है, लेकिन आपको इसकी अक्सर ज़रूरत नहीं पड़ेगी।
+
+यदि आप चाहते हैं कि:
+
+* `q` query parameter को बिना `Query` और बिना किसी default value के घोषित करें
+* path parameter `item_id` को `Path` का उपयोग करके घोषित करें
+* उन्हें अलग क्रम में रखें
+* `Annotated` का उपयोग न करें
+
+...तो Python में इसके लिए एक छोटी विशेष syntax है।
+
+function के पहले parameter के रूप में `*` पास करें।
+
+Python उस `*` के साथ कुछ नहीं करेगा, लेकिन उसे पता चल जाएगा कि उसके बाद आने वाले सभी parameters को keyword arguments (key-value pairs) के रूप में call किया जाना चाहिए, जिन्हें <abbr title="From: K-ey W-ord Arg-uments - से: K-ey W-ord Arg-uments"><code>kwargs</code></abbr> भी कहा जाता है। भले ही उनके पास default value न हो।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial003_py310.py hl[7] *}
+
+### `Annotated` के साथ बेहतर { #better-with-annotated }
+
+ध्यान रखें कि यदि आप `Annotated` का उपयोग करते हैं, तो चूँकि आप function parameter default values का उपयोग नहीं कर रहे हैं, आपको यह समस्या नहीं होगी, और शायद आपको `*` का उपयोग करने की ज़रूरत नहीं पड़ेगी।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial003_an_py310.py hl[10] *}
+
+## Number validations: greater than or equal { #number-validations-greater-than-or-equal }
+
+`Query` और `Path` (और अन्य जिन्हें आप बाद में देखेंगे) के साथ आप number constraints घोषित कर सकते हैं।
+
+यहाँ, `ge=1` के साथ, `item_id` को `1` से "`g`reater than or `e`qual" integer number होना होगा।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py310.py hl[10] *}
+
+## Number validations: greater than और less than or equal { #number-validations-greater-than-and-less-than-or-equal }
+
+यही बात इन पर भी लागू होती है:
+
+* `gt`: `g`reater `t`han
+* `le`: `l`ess than or `e`qual
+
+{* ../../docs_src/path_params_numeric_validations/tutorial005_an_py310.py hl[10] *}
+
+## Number validations: floats, greater than और less than { #number-validations-floats-greater-than-and-less-than }
+
+Number validations `float` values के लिए भी काम करती हैं।
+
+यहीं पर <abbr title="greater than - इससे अधिक"><code>gt</code></abbr> घोषित कर पाना महत्वपूर्ण हो जाता है, सिर्फ <abbr title="greater than or equal - इससे अधिक या बराबर"><code>ge</code></abbr> नहीं। क्योंकि इसके साथ आप, उदाहरण के लिए, यह require कर सकते हैं कि कोई value `0` से अधिक होनी चाहिए, भले ही वह `1` से कम हो।
+
+तो, `0.5` एक valid value होगा। लेकिन `0.0` या `0` नहीं होंगे।
+
+और यही बात <abbr title="less than - इससे कम"><code>lt</code></abbr> के लिए भी है।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py310.py hl[13] *}
+
+## Recap { #recap }
+
+`Query`, `Path` (और अन्य जिन्हें आपने अभी तक नहीं देखा है) के साथ आप metadata और string validations उसी तरह घोषित कर सकते हैं जैसे [Query Parameters और String Validations](query-params-str-validations.md) के साथ।
+
+और आप numeric validations भी घोषित कर सकते हैं:
+
+* `gt`: `g`reater `t`han
+* `ge`: `g`reater than or `e`qual
+* `lt`: `l`ess `t`han
+* `le`: `l`ess than or `e`qual
+
+/// note | नोट
+
+`Query`, `Path`, और अन्य classes जिन्हें आप बाद में देखेंगे, एक common `Param` class की subclasses हैं।
+
+वे सभी अतिरिक्त validation और metadata के लिए वही parameters साझा करती हैं जिन्हें आपने देखा है।
+
+///
+
+/// note | तकनीकी विवरण
+
+जब आप `fastapi` से `Query`, `Path` और अन्य import करते हैं, तो वे वास्तव में functions होते हैं।
+
+जब उन्हें call किया जाता है, तो वे उसी नाम की classes के instances return करते हैं।
+
+तो, आप `Query` import करते हैं, जो एक function है। और जब आप इसे call करते हैं, तो यह `Query` नाम की class का एक instance return करता है।
+
+ये functions इसलिए हैं (classes को सीधे उपयोग करने के बजाय) ताकि आपका editor उनके types के बारे में errors mark न करे।
+
+इस तरह आप उन errors को ignore करने के लिए custom configurations जोड़े बिना अपने सामान्य editor और coding tools का उपयोग कर सकते हैं।
+
+///

docs/hi/docs/tutorial/path-params.md

@@ -0,0 +1,251 @@
+# Path Parameters { #path-parameters }
+
+आप Python format strings द्वारा इस्तेमाल किए जाने वाले समान syntax के साथ path "parameters" या "variables" declare कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial001_py310.py hl[6:7] *}
+
+path parameter `item_id` की value आपके function को argument `item_id` के रूप में pass की जाएगी।
+
+इसलिए, अगर आप यह example run करते हैं और [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo) पर जाते हैं, तो आपको ऐसा response दिखाई देगा:
+
+```JSON
+{"item_id":"foo"}
+```
+
+## Types के साथ Path parameters { #path-parameters-with-types }
+
+आप standard Python type annotations का उपयोग करके function में किसी path parameter का type declare कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial002_py310.py hl[7] *}
+
+इस मामले में, `item_id` को `int` declare किया गया है।
+
+/// tip | सुझाव
+
+इससे आपको अपने function के अंदर editor support मिलेगा, जिसमें error checks, completion आदि शामिल हैं।
+
+///
+
+## Data <dfn title="इसके नाम से भी जाना जाता है: serialization, parsing, marshalling">conversion</dfn> { #data-conversion }
+
+अगर आप यह example run करते हैं और अपने browser में [http://127.0.0.1:8000/items/3](http://127.0.0.1:8000/items/3) खोलते हैं, तो आपको ऐसा response दिखाई देगा:
+
+```JSON
+{"item_id":3}
+```
+
+/// tip | सुझाव
+
+ध्यान दें कि आपके function ने जो value प्राप्त की (और return की) वह `3` है, Python `int` के रूप में, न कि string `"3"`।
+
+तो, उस type declaration के साथ, **FastAPI** आपको automatic request <dfn title="HTTP request से आने वाली string को Python data में बदलना">"parsing"</dfn> देता है।
+
+///
+
+## Data validation { #data-validation }
+
+लेकिन अगर आप browser में [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo) पर जाते हैं, तो आपको ऐसा अच्छा HTTP error दिखाई देगा:
+
+```JSON
+{
+  "detail": [
+    {
+      "type": "int_parsing",
+      "loc": [
+        "path",
+        "item_id"
+      ],
+      "msg": "Input should be a valid integer, unable to parse string as an integer",
+      "input": "foo"
+    }
+  ]
+}
+```
+
+क्योंकि path parameter `item_id` की value `"foo"` थी, जो कि `int` नहीं है।
+
+अगर आपने `int` के बजाय `float` दिया, तो भी वही error दिखाई देगा, जैसे: [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)
+
+/// tip | सुझाव
+
+तो, उसी Python type declaration के साथ, **FastAPI** आपको data validation देता है।
+
+ध्यान दें कि error यह भी स्पष्ट रूप से बताता है कि validation किस जगह pass नहीं हुआ।
+
+यह आपके API के साथ interact करने वाले code को develop और debug करते समय बेहद मददगार होता है।
+
+///
+
+## Documentation { #documentation }
+
+और जब आप अपने browser में [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) खोलते हैं, तो आपको ऐसा automatic, interactive, API documentation दिखाई देगा:
+
+<img src="/img/tutorial/path-params/image01.png">
+
+/// tip | सुझाव
+
+फिर से, बस उसी Python type declaration के साथ, **FastAPI** आपको automatic, interactive documentation देता है (Swagger UI को integrate करते हुए)।
+
+ध्यान दें कि path parameter को integer के रूप में declare किया गया है।
+
+///
+
+## Standard-आधारित लाभ, वैकल्पिक documentation { #standards-based-benefits-alternative-documentation }
+
+और क्योंकि generate किया गया schema [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md) standard से है, इसलिए कई compatible tools हैं।
+
+इसी वजह से, **FastAPI** स्वयं एक वैकल्पिक API documentation प्रदान करता है (ReDoc का उपयोग करते हुए), जिसे आप [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) पर access कर सकते हैं:
+
+<img src="/img/tutorial/path-params/image02.png">
+
+इसी तरह, कई compatible tools हैं। इनमें कई भाषाओं के लिए code generation tools भी शामिल हैं।
+
+## Pydantic { #pydantic }
+
+सारा data validation अंदरूनी तौर पर [Pydantic](https://docs.pydantic.dev/) द्वारा किया जाता है, इसलिए आपको इसके सभी लाभ मिलते हैं। और आप जानते हैं कि आप अच्छे हाथों में हैं।
+
+आप `str`, `float`, `bool` और कई अन्य जटिल data types के साथ वही type declarations इस्तेमाल कर सकते हैं।
+
+इनमें से कई को tutorial के अगले chapters में explore किया गया है।
+
+## क्रम मायने रखता है { #order-matters }
+
+*path operations* बनाते समय, आपको ऐसी स्थितियाँ मिल सकती हैं जहाँ आपके पास एक fixed path हो।
+
+जैसे `/users/me`, मान लें कि यह current user के बारे में data प्राप्त करने के लिए है।
+
+और फिर आपके पास `/users/{user_id}` path भी हो सकता है, किसी specific user के बारे में किसी user ID से data प्राप्त करने के लिए।
+
+क्योंकि *path operations* का evaluation क्रम में किया जाता है, आपको यह सुनिश्चित करना होगा कि `/users/me` के लिए path, `/users/{user_id}` वाले path से पहले declare किया गया हो:
+
+{* ../../docs_src/path_params/tutorial003_py310.py hl[6,11] *}
+
+अन्यथा, `/users/{user_id}` के लिए path `/users/me` से भी match करेगा, यह "सोचते हुए" कि उसे `user_id` parameter मिल रहा है जिसकी value `"me"` है।
+
+इसी तरह, आप किसी path operation को फिर से define नहीं कर सकते:
+
+{* ../../docs_src/path_params/tutorial003b_py310.py hl[6,11] *}
+
+पहला वाला हमेशा इस्तेमाल किया जाएगा क्योंकि path पहले match करता है।
+
+## पहले से तय values { #predefined-values }
+
+अगर आपके पास ऐसा *path operation* है जो एक *path parameter* प्राप्त करता है, लेकिन आप चाहते हैं कि संभव valid *path parameter* values पहले से तय हों, तो आप standard Python <abbr title="Enumeration">`Enum`</abbr> का उपयोग कर सकते हैं।
+
+### एक `Enum` class बनाएं { #create-an-enum-class }
+
+`Enum` import करें और एक sub-class बनाएं जो `str` और `Enum` से inherit करती हो।
+
+`str` से inherit करने पर API docs यह जान पाएंगे कि values का type `string` होना चाहिए और उन्हें सही तरह से render कर पाएंगे।
+
+फिर fixed values के साथ class attributes बनाएं, जो उपलब्ध valid values होंगी:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[1,6:9] *}
+
+/// tip | सुझाव
+
+अगर आप सोच रहे हैं, "AlexNet", "ResNet", और "LeNet" बस Machine Learning <dfn title="तकनीकी रूप से, Deep Learning model architectures">models</dfn> के नाम हैं।
+
+///
+
+### एक *path parameter* declare करें { #declare-a-path-parameter }
+
+फिर आपके द्वारा बनाई गई enum class (`ModelName`) का उपयोग करके type annotation के साथ एक *path parameter* बनाएं:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[16] *}
+
+### Docs देखें { #check-the-docs }
+
+क्योंकि *path parameter* के लिए उपलब्ध values पहले से तय हैं, interactive docs उन्हें अच्छे से दिखा सकते हैं:
+
+<img src="/img/tutorial/path-params/image03.png">
+
+### Python *enumerations* के साथ काम करना { #working-with-python-enumerations }
+
+*path parameter* की value एक *enumeration member* होगी।
+
+#### *Enumeration members* की तुलना करें { #compare-enumeration-members }
+
+आप इसकी तुलना अपने बनाए हुए enum `ModelName` में मौजूद *enumeration member* से कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[17] *}
+
+#### *Enumeration value* प्राप्त करें { #get-the-enumeration-value }
+
+आप `model_name.value` का उपयोग करके actual value (इस मामले में एक `str`) प्राप्त कर सकते हैं, या सामान्य रूप से, `your_enum_member.value`:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[20] *}
+
+/// tip | सुझाव
+
+आप `ModelName.lenet.value` के साथ value `"lenet"` भी access कर सकते हैं।
+
+///
+
+#### *Enumeration members* return करें { #return-enumeration-members }
+
+आप अपने *path operation* से *enum members* return कर सकते हैं, यहाँ तक कि JSON body में nested भी (जैसे एक `dict`)।
+
+Client को return करने से पहले उन्हें उनकी संबंधित values (इस मामले में strings) में convert कर दिया जाएगा:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[18,21,23] *}
+
+अपने client में आपको ऐसा JSON response मिलेगा:
+
+```JSON
+{
+  "model_name": "alexnet",
+  "message": "Deep Learning FTW!"
+}
+```
+
+## Paths रखने वाले Path parameters { #path-parameters-containing-paths }
+
+मान लें आपके पास path `/files/{file_path}` के साथ एक *path operation* है।
+
+लेकिन आपको `file_path` में स्वयं एक *path* रखना है, जैसे `home/johndoe/myfile.txt`।
+
+तो, उस file के लिए URL कुछ ऐसा होगा: `/files/home/johndoe/myfile.txt`।
+
+### OpenAPI support { #openapi-support }
+
+OpenAPI किसी *path parameter* को उसके अंदर एक *path* रखने के लिए declare करने का तरीका support नहीं करता, क्योंकि इससे ऐसे scenarios बन सकते हैं जिन्हें test और define करना कठिन हो।
+
+फिर भी, आप **FastAPI** में Starlette के internal tools में से एक का उपयोग करके यह कर सकते हैं।
+
+और docs फिर भी काम करेंगे, हालांकि ऐसा कोई documentation नहीं जोड़ेंगे जो बताए कि parameter में path होना चाहिए।
+
+### Path convertor { #path-convertor }
+
+Starlette से सीधे एक option का उपयोग करके, आप इस तरह के URL का उपयोग करते हुए एक *path* रखने वाला *path parameter* declare कर सकते हैं:
+
+```
+/files/{file_path:path}
+```
+
+इस मामले में, parameter का नाम `file_path` है, और आखिरी हिस्सा, `:path`, इसे बताता है कि parameter किसी भी *path* से match करना चाहिए।
+
+तो, आप इसे इसके साथ इस्तेमाल कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial004_py310.py hl[6] *}
+
+/// tip | सुझाव
+
+आपको parameter में `/home/johndoe/myfile.txt` रखना पड़ सकता है, leading slash (`/`) के साथ।
+
+उस मामले में, URL होगा: `/files//home/johndoe/myfile.txt`, `files` और `home` के बीच double slash (`//`) के साथ।
+
+///
+
+## Recap { #recap }
+
+**FastAPI** के साथ, छोटे, सहज और standard Python type declarations का उपयोग करके, आपको मिलता है:
+
+* Editor support: error checks, autocompletion आदि।
+* Data "<dfn title="HTTP request से आने वाली string को Python data में बदलना">parsing</dfn>"
+* Data validation
+* API annotation और automatic documentation
+
+और आपको इन्हें केवल एक बार declare करना होता है।
+
+वैकल्पिक frameworks की तुलना में **FastAPI** का शायद यही मुख्य दिखने वाला लाभ है (raw performance के अलावा)।

docs/hi/docs/tutorial/query-param-models.md

@@ -0,0 +1,68 @@
+# Query Parameter Models { #query-parameter-models }
+
+अगर आपके पास संबंधित **query parameters** का एक समूह है, तो आप उन्हें declare करने के लिए एक **Pydantic model** बना सकते हैं।
+
+इससे आप **model को फिर से उपयोग** कर पाएँगे, **कई जगहों** पर, और साथ ही सभी parameters के लिए validations और metadata एक साथ declare कर पाएँगे। 😎
+
+/// note | नोट
+
+यह FastAPI version `0.115.0` से supported है। 🤓
+
+///
+
+## Pydantic Model के साथ Query Parameters { #query-parameters-with-a-pydantic-model }
+
+जिन **query parameters** की आपको ज़रूरत है उन्हें एक **Pydantic model** में declare करें, और फिर parameter को `Query` के रूप में declare करें:
+
+{* ../../docs_src/query_param_models/tutorial001_an_py310.py hl[9:13,17] *}
+
+**FastAPI** request में मौजूद **query parameters** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs देखें { #check-the-docs }
+
+आप `/docs` पर docs UI में query parameters देख सकते हैं:
+
+<div class="screenshot">
+<img src="/img/tutorial/query-param-models/image01.png">
+</div>
+
+## Extra Query Parameters को Forbid करें { #forbid-extra-query-parameters }
+
+कुछ विशेष use cases में (शायद बहुत आम नहीं), आप उन query parameters को **restrict** करना चाह सकते हैं जिन्हें आप receive करना चाहते हैं।
+
+आप किसी भी `extra` fields को `forbid` करने के लिए Pydantic की model configuration का उपयोग कर सकते हैं:
+
+{* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *}
+
+अगर कोई client **query parameters** में कुछ **extra** data भेजने की कोशिश करता है, तो उसे एक **error** response मिलेगा।
+
+उदाहरण के लिए, अगर client `plumbus` value के साथ `tool` query parameter भेजने की कोशिश करता है, जैसे:
+
+```http
+https://example.com/items/?limit=10&tool=plumbus
+```
+
+उसे एक **error** response मिलेगा जो बताएगा कि query parameter `tool` allowed नहीं है:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["query", "tool"],
+            "msg": "Extra inputs are not permitted",
+            "input": "plumbus"
+        }
+    ]
+}
+```
+
+## सारांश { #summary }
+
+आप **FastAPI** में **query parameters** declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं। 😎
+
+/// tip | सुझाव
+
+Spoiler alert: आप cookies और headers declare करने के लिए भी Pydantic models का उपयोग कर सकते हैं, लेकिन आप इसके बारे में tutorial में बाद में पढ़ेंगे। 🤫
+
+///

docs/hi/docs/tutorial/query-params-str-validations.md

@@ -0,0 +1,450 @@
+# Query Parameters और String Validations { #query-parameters-and-string-validations }
+
+**FastAPI** आपको अपने parameters के लिए अतिरिक्त जानकारी और validation declare करने देता है।
+
+इस application को example के रूप में लेते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *}
+
+query parameter `q` का type `str | None` है, इसका मतलब है कि यह type `str` का है लेकिन `None` भी हो सकता है, और वास्तव में, default value `None` है, इसलिए FastAPI जान जाएगा कि यह required नहीं है।
+
+/// note | नोट
+
+FastAPI जान जाएगा कि `q` की value required नहीं है क्योंकि default value `= None` है।
+
+`str | None` होने से आपका editor आपको बेहतर support दे पाएगा और errors detect कर पाएगा।
+
+///
+
+## अतिरिक्त validation { #additional-validation }
+
+हम यह enforce करने जा रहे हैं कि भले ही `q` optional हो, जब भी यह provide किया जाए, **इसकी length 50 characters से अधिक न हो**।
+
+### `Query` और `Annotated` import करें { #import-query-and-annotated }
+
+इसे हासिल करने के लिए, पहले import करें:
+
+* `fastapi` से `Query`
+* `typing` से `Annotated`
+
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[1,3] *}
+
+/// note | नोट
+
+FastAPI ने version 0.95.0 में `Annotated` के लिए support जोड़ा (और इसकी recommendation शुरू की)।
+
+अगर आपके पास पुराना version है, तो `Annotated` use करने की कोशिश करने पर आपको errors मिलेंगे।
+
+`Annotated` use करने से पहले सुनिश्चित करें कि आप [FastAPI version Upgrade करें](../deployment/versions.md#upgrading-the-fastapi-versions) कम से कम 0.95.1 तक।
+
+///
+
+## `q` parameter के type में `Annotated` use करें { #use-annotated-in-the-type-for-the-q-parameter }
+
+याद है मैंने आपको पहले बताया था कि [Python Types Intro](../python-types.md#type-hints-with-metadata-annotations) में `Annotated` का उपयोग आपके parameters में metadata जोड़ने के लिए किया जा सकता है?
+
+अब इसे FastAPI के साथ use करने का समय है। 🚀
+
+हमारे पास यह type annotation था:
+
+```Python
+q: str | None = None
+```
+
+हम इसे `Annotated` के साथ wrap करेंगे, तो यह बन जाता है:
+
+```Python
+q: Annotated[str | None] = None
+```
+
+इन दोनों versions का मतलब एक ही है, `q` एक parameter है जो `str` या `None` हो सकता है, और default रूप से, यह `None` है।
+
+अब मज़ेदार चीज़ों पर चलते हैं। 🎉
+
+## `q` parameter में `Annotated` में `Query` जोड़ें { #add-query-to-annotated-in-the-q-parameter }
+
+अब जब हमारे पास यह `Annotated` है जहाँ हम अधिक जानकारी रख सकते हैं (इस case में कुछ अतिरिक्त validation), `Annotated` के अंदर `Query` जोड़ें, और parameter `max_length` को `50` पर set करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *}
+
+ध्यान दें कि default value अभी भी `None` है, इसलिए parameter अभी भी optional है।
+
+लेकिन अब, `Annotated` के अंदर `Query(max_length=50)` होने से, हम FastAPI को बता रहे हैं कि हम चाहते हैं कि इस value के लिए **अतिरिक्त validation** हो, हम चाहते हैं कि इसमें अधिकतम 50 characters हों। 😎
+
+/// tip | टिप
+
+यहाँ हम `Query()` use कर रहे हैं क्योंकि यह एक **query parameter** है। बाद में हम `Path()`, `Body()`, `Header()`, और `Cookie()` जैसे अन्य देखेंगे, जो `Query()` जैसे ही arguments accept करते हैं।
+
+///
+
+FastAPI अब:
+
+* data को **Validate** करेगा यह सुनिश्चित करते हुए कि max length 50 characters है
+* जब data valid नहीं होगा तो client के लिए **clear error** दिखाएगा
+* OpenAPI schema *path operation* में parameter को **Document** करेगा (ताकि यह **automatic docs UI** में दिखाई दे)
+
+## Alternative (पुराना): default value के रूप में `Query` { #alternative-old-query-as-the-default-value }
+
+FastAPI के पिछले versions (<dfn title="2023-03 से पहले">0.95.0</dfn> से पहले) में आपको अपने parameter की default value के रूप में `Query` use करना required था, बजाय इसे `Annotated` में रखने के, इसकी अच्छी संभावना है कि आपको आसपास ऐसा code दिखेगा, इसलिए मैं आपको इसे समझाऊंगा।
+
+/// tip | टिप
+
+नए code के लिए और जब भी संभव हो, ऊपर समझाए अनुसार `Annotated` use करें। इसके कई फायदे हैं (नीचे समझाए गए हैं) और कोई नुकसान नहीं। 🍰
+
+///
+
+इस तरह आप अपने function parameter की default value के रूप में `Query()` use करेंगे, parameter `max_length` को 50 पर set करते हुए:
+
+{* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *}
+
+चूँकि इस case में (`Annotated` use किए बिना) हमें function में default value `None` को `Query()` से replace करना होता है, अब हमें parameter `Query(default=None)` के साथ default value set करनी होगी, यह उस default value को define करने का वही उद्देश्य पूरा करता है (कम से कम FastAPI के लिए)।
+
+तो:
+
+```Python
+q: str | None = Query(default=None)
+```
+
+...parameter को optional बनाता है, `None` की default value के साथ, बिल्कुल इसके समान:
+
+
+```Python
+q: str | None = None
+```
+
+लेकिन `Query` version इसे स्पष्ट रूप से query parameter के रूप में declare करता है।
+
+फिर, हम `Query` को और parameters pass कर सकते हैं। इस case में, `max_length` parameter जो strings पर apply होता है:
+
+```Python
+q: str | None = Query(default=None, max_length=50)
+```
+
+यह data को validate करेगा, data valid न होने पर clear error दिखाएगा, और OpenAPI schema *path operation* में parameter को document करेगा।
+
+### default value के रूप में या `Annotated` में `Query` { #query-as-the-default-value-or-in-annotated }
+
+ध्यान रखें कि `Annotated` के अंदर `Query` use करते समय आप `Query` के लिए `default` parameter use नहीं कर सकते।
+
+इसके बजाय, function parameter की वास्तविक default value use करें। अन्यथा, यह inconsistent होगा।
+
+उदाहरण के लिए, इसकी अनुमति नहीं है:
+
+```Python
+q: Annotated[str, Query(default="rick")] = "morty"
+```
+
+...क्योंकि यह clear नहीं है कि default value `"rick"` होनी चाहिए या `"morty"`।
+
+तो, आप use करेंगे (preferably):
+
+```Python
+q: Annotated[str, Query()] = "rick"
+```
+
+...या पुराने code bases में आपको मिलेगा:
+
+```Python
+q: str = Query(default="rick")
+```
+
+### `Annotated` के फायदे { #advantages-of-annotated }
+
+function parameters में default value के बजाय **`Annotated` use करने की recommendation है**, यह कई कारणों से **बेहतर** है। 🤓
+
+**function parameter** की **default** value ही **वास्तविक default** value है, यह सामान्य रूप से Python के साथ अधिक intuitive है। 😌
+
+आप उसी function को FastAPI के बिना **अन्य जगहों** पर **call** कर सकते हैं, और यह **उम्मीद के अनुसार काम** करेगा। अगर कोई **required** parameter है (बिना default value के), तो आपका **editor** आपको error के साथ बता देगा, **Python** भी required parameter pass किए बिना इसे run करने पर complain करेगा।
+
+जब आप `Annotated` use नहीं करते और इसके बजाय **(पुराना) default value style** use करते हैं, अगर आप उस function को FastAPI के बिना **अन्य जगहों** पर call करते हैं, तो आपको function को सही से काम कराने के लिए arguments pass करना **याद रखना** होगा, अन्यथा values आपकी अपेक्षा से अलग होंगी (जैसे `str` के बजाय `QueryInfo` या कुछ similar)। और आपका editor complain नहीं करेगा, और Python भी उस function को run करते समय complain नहीं करेगा, केवल तब जब अंदर के operations error दें।
+
+क्योंकि `Annotated` में एक से अधिक metadata annotation हो सकते हैं, अब आप उसी function को अन्य tools के साथ भी use कर सकते हैं, जैसे [Typer](https://typer.tiangolo.com/)। 🚀
+
+## और validations जोड़ें { #add-more-validations }
+
+आप parameter `min_length` भी जोड़ सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *}
+
+## regular expressions जोड़ें { #add-regular-expressions }
+
+आप एक <dfn title="एक regular expression, regex या regexp characters का ऐसा sequence है जो strings के लिए search pattern define करता है।">regular expression</dfn> `pattern` define कर सकते हैं जिससे parameter match करना चाहिए:
+
+{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
+
+यह specific regular expression pattern check करता है कि received parameter value:
+
+* `^`: निम्न characters से शुरू होती है, पहले कोई characters नहीं हैं।
+* `fixedquery`: exact value `fixedquery` रखती है।
+* `$`: वहीं समाप्त होती है, `fixedquery` के बाद कोई और characters नहीं हैं।
+
+अगर आप इन सभी **"regular expression"** ideas से खोया हुआ महसूस करते हैं, तो चिंता न करें। यह कई लोगों के लिए कठिन topic है। आप अभी regular expressions की जरूरत के बिना भी बहुत कुछ कर सकते हैं।
+
+अब आप जानते हैं कि जब भी आपको इनकी जरूरत हो, आप इन्हें **FastAPI** में use कर सकते हैं।
+
+## Default values { #default-values }
+
+बेशक, आप `None` के अलावा default values use कर सकते हैं।
+
+मान लीजिए कि आप `q` query parameter को `3` की `min_length` और `"fixedquery"` की default value के साथ declare करना चाहते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial005_an_py310.py hl[9] *}
+
+/// note | नोट
+
+`None` सहित किसी भी type की default value होना parameter को optional (not required) बनाता है।
+
+///
+
+## Required parameters { #required-parameters }
+
+जब हमें अधिक validations या metadata declare करने की जरूरत नहीं होती, तो हम default value declare न करके ही `q` query parameter को required बना सकते हैं, जैसे:
+
+```Python
+q: str
+```
+
+इसके बजाय:
+
+```Python
+q: str | None = None
+```
+
+लेकिन अब हम इसे `Query` के साथ declare कर रहे हैं, उदाहरण के लिए ऐसे:
+
+```Python
+q: Annotated[str | None, Query(min_length=3)] = None
+```
+
+तो, जब आपको `Query` use करते हुए किसी value को required के रूप में declare करना हो, तो आप बस default value declare न करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial006_an_py310.py hl[9] *}
+
+### Required, `None` हो सकता है { #required-can-be-none }
+
+आप declare कर सकते हैं कि parameter `None` accept कर सकता है, लेकिन फिर भी यह required है। यह clients को value भेजने के लिए मजबूर करेगा, भले ही value `None` हो।
+
+ऐसा करने के लिए, आप declare कर सकते हैं कि `None` एक valid type है लेकिन बस default value declare न करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
+
+## Query parameter list / multiple values { #query-parameter-list-multiple-values }
+
+जब आप query parameter को स्पष्ट रूप से `Query` के साथ define करते हैं तो आप इसे values की list receive करने के लिए भी declare कर सकते हैं, या दूसरे शब्दों में, multiple values receive करने के लिए।
+
+उदाहरण के लिए, query parameter `q` declare करने के लिए जो URL में कई बार आ सकता है, आप लिख सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *}
+
+फिर, ऐसे URL के साथ:
+
+```
+http://localhost:8000/items/?q=foo&q=bar
+```
+
+आप multiple `q` *query parameters* की values (`foo` और `bar`) को अपने *path operation function* के अंदर Python `list` में, *function parameter* `q` में receive करेंगे।
+
+तो, उस URL का response होगा:
+
+```JSON
+{
+  "q": [
+    "foo",
+    "bar"
+  ]
+}
+```
+
+/// tip | टिप
+
+ऊपर के example की तरह, `list` type वाला query parameter declare करने के लिए, आपको स्पष्ट रूप से `Query` use करना होगा, अन्यथा इसे request body के रूप में interpret किया जाएगा।
+
+///
+
+interactive API docs accordingly update होंगे, ताकि multiple values allow हो सकें:
+
+<img src="/img/tutorial/query-params-str-validations/image02.png">
+
+### Defaults के साथ Query parameter list / multiple values { #query-parameter-list-multiple-values-with-defaults }
+
+अगर कोई values provide नहीं की गई हैं, तो आप values की default `list` भी define कर सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial012_an_py310.py hl[9] *}
+
+अगर आप यहाँ जाते हैं:
+
+```
+http://localhost:8000/items/
+```
+
+`q` का default होगा: `["foo", "bar"]` और आपका response होगा:
+
+```JSON
+{
+  "q": [
+    "foo",
+    "bar"
+  ]
+}
+```
+
+#### केवल `list` use करना { #using-just-list }
+
+आप `list[str]` के बजाय सीधे `list` भी use कर सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial013_an_py310.py hl[9] *}
+
+/// note | नोट
+
+ध्यान रखें कि इस case में, FastAPI list की contents check नहीं करेगा।
+
+उदाहरण के लिए, `list[int]` check (और document) करेगा कि list की contents integers हैं। लेकिन केवल `list` ऐसा नहीं करेगा।
+
+///
+
+## अधिक metadata declare करें { #declare-more-metadata }
+
+आप parameter के बारे में अधिक जानकारी जोड़ सकते हैं।
+
+वह जानकारी generated OpenAPI में शामिल होगी और documentation user interfaces और external tools द्वारा use की जाएगी।
+
+/// note | नोट
+
+ध्यान रखें कि अलग-अलग tools में OpenAPI support के अलग-अलग levels हो सकते हैं।
+
+उनमें से कुछ अभी declare की गई सारी extra information नहीं दिखा सकते, हालांकि अधिकतर cases में, missing feature पहले से ही development के लिए planned है।
+
+///
+
+आप एक `title` जोड़ सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
+
+और एक `description`:
+
+{* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
+
+## Alias parameters { #alias-parameters }
+
+कल्पना करें कि आप parameter को `item-query` बनाना चाहते हैं।
+
+जैसे:
+
+```
+http://127.0.0.1:8000/items/?item-query=foobaritems
+```
+
+लेकिन `item-query` valid Python variable name नहीं है।
+
+सबसे निकटतम `item_query` होगा।
+
+लेकिन आपको अभी भी यह exactly `item-query` ही चाहिए...
+
+तब आप एक `alias` declare कर सकते हैं, और वही alias parameter value खोजने के लिए use किया जाएगा:
+
+{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
+
+## Parameters को deprecate करना { #deprecating-parameters }
+
+अब मान लीजिए कि आपको यह parameter अब पसंद नहीं है।
+
+आपको इसे कुछ समय के लिए वहीं छोड़ना होगा क्योंकि clients इसे use कर रहे हैं, लेकिन आप चाहते हैं कि docs इसे स्पष्ट रूप से <dfn title="obsolete, इसका उपयोग न करने की recommendation है">deprecated</dfn> के रूप में दिखाएँ।
+
+फिर parameter `deprecated=True` को `Query` में pass करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
+
+docs इसे इस तरह दिखाएँगे:
+
+<img src="/img/tutorial/query-params-str-validations/image01.png">
+
+## OpenAPI से parameters exclude करें { #exclude-parameters-from-openapi }
+
+generated OpenAPI schema से query parameter exclude करने के लिए (और इस प्रकार, automatic documentation systems से), `Query` के parameter `include_in_schema` को `False` पर set करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
+
+## Custom Validation { #custom-validation }
+
+ऐसे cases हो सकते हैं जहाँ आपको कुछ **custom validation** करना पड़े जो ऊपर दिखाए गए parameters से नहीं किया जा सकता।
+
+ऐसे cases में, आप एक **custom validator function** use कर सकते हैं जो normal validation के बाद apply होता है (जैसे value के `str` होने की validation के बाद)।
+
+आप इसे `Annotated` के अंदर [Pydantic के `AfterValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) का उपयोग करके हासिल कर सकते हैं।
+
+/// tip | टिप
+
+Pydantic में [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) और अन्य भी हैं। 🤓
+
+///
+
+उदाहरण के लिए, यह custom validator check करता है कि item ID किसी <abbr title="International Standard Book Number - अंतर्राष्ट्रीय मानक पुस्तक संख्या">ISBN</abbr> book number के लिए `isbn-` से शुरू होती है या किसी <abbr title="Internet Movie Database - इंटरनेट मूवी डेटाबेस: फिल्मों के बारे में जानकारी वाली एक वेबसाइट">IMDB</abbr> movie URL ID के लिए `imdb-` से:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
+
+/// note | नोट
+
+यह Pydantic version 2 या उससे ऊपर के साथ available है। 😎
+
+///
+
+/// tip | टिप
+
+अगर आपको किसी भी प्रकार की validation करनी है जिसके लिए किसी **external component** से communicate करना required है, जैसे database या कोई अन्य API, तो आपको इसके बजाय **FastAPI Dependencies** use करनी चाहिए, आप इनके बारे में बाद में सीखेंगे।
+
+ये custom validators उन चीज़ों के लिए हैं जिन्हें request में provide किए गए **सिर्फ** **उसी data** से check किया जा सकता है।
+
+///
+
+### उस Code को समझें { #understand-that-code }
+
+महत्वपूर्ण बात बस **`Annotated` के अंदर एक function के साथ `AfterValidator` use करना** है। आप चाहें तो इस part को skip कर सकते हैं। 🤸
+
+---
+
+लेकिन अगर आप इस specific code example के बारे में curious हैं और अभी भी entertained हैं, तो यहाँ कुछ extra details हैं।
+
+#### `value.startswith()` के साथ String { #string-with-value-startswith }
+
+क्या आपने ध्यान दिया? `value.startswith()` use करने वाली string tuple ले सकती है, और यह tuple की हर value check करेगी:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
+
+#### एक Random Item { #a-random-item }
+
+`data.items()` के साथ हमें tuples वाला एक <dfn title="ऐसी चीज़ जिस पर हम for loop से iterate कर सकते हैं, जैसे list, set, आदि।">iterable object</dfn> मिलता है जिसमें हर dictionary item के लिए key और value होती है।
+
+हम इस iterable object को `list(data.items())` के साथ proper `list` में convert करते हैं।
+
+फिर `random.choice()` के साथ हम list से एक **random value** प्राप्त कर सकते हैं, तो हमें `(id, name)` वाला tuple मिलता है। यह कुछ ऐसा होगा `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`।
+
+फिर हम tuple की **उन दो values को assign** करते हैं variables `id` और `name` को।
+
+तो, अगर user ने item ID provide नहीं की, तब भी उन्हें एक random suggestion receive होगा।
+
+...हम यह सब **एक single simple line** में करते हैं। 🤯 क्या आपको Python पसंद नहीं है? 🐍
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
+
+## Recap { #recap }
+
+आप अपने parameters के लिए अतिरिक्त validations और metadata declare कर सकते हैं।
+
+Generic validations और metadata:
+
+* `alias`
+* `title`
+* `description`
+* `deprecated`
+
+Strings के लिए specific validations:
+
+* `min_length`
+* `max_length`
+* `pattern`
+
+`AfterValidator` का उपयोग करके custom validations।
+
+इन examples में आपने देखा कि `str` values के लिए validations कैसे declare करें।
+
+अगले chapters देखें ताकि आप सीख सकें कि numbers जैसे अन्य types के लिए validations कैसे declare करें।

docs/hi/docs/tutorial/query-params.md

@@ -0,0 +1,188 @@
+# Query Parameters { #query-parameters }
+
+जब आप ऐसे दूसरे function parameters declare करते हैं जो path parameters का हिस्सा नहीं हैं, तो उन्हें अपने-आप "query" parameters के रूप में समझा जाता है।
+
+{* ../../docs_src/query_params/tutorial001_py310.py hl[9] *}
+
+query उन key-value pairs का सेट है जो URL में `?` के बाद आते हैं, और `&` characters से अलग किए जाते हैं।
+
+उदाहरण के लिए, इस URL में:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+...query parameters हैं:
+
+* `skip`: `0` value के साथ
+* `limit`: `10` value के साथ
+
+क्योंकि वे URL का हिस्सा हैं, वे "स्वाभाविक रूप से" strings होते हैं।
+
+लेकिन जब आप उन्हें Python types के साथ declare करते हैं (ऊपर दिए गए उदाहरण में, `int` के रूप में), तो उन्हें उस type में convert किया जाता है और उसके अनुसार validate किया जाता है।
+
+path parameters पर लागू होने वाली सभी वही प्रक्रियाएँ query parameters पर भी लागू होती हैं:
+
+* Editor support (स्पष्ट रूप से)
+* Data <dfn title="HTTP request से आने वाली string को Python data में बदलना">"parsing"</dfn>
+* Data validation
+* Automatic documentation
+
+## Defaults { #defaults }
+
+क्योंकि query parameters किसी path का fixed हिस्सा नहीं होते, वे optional हो सकते हैं और उनके default values हो सकते हैं।
+
+ऊपर दिए गए उदाहरण में उनके default values `skip=0` और `limit=10` हैं।
+
+तो, इस URL पर जाना:
+
+```
+http://127.0.0.1:8000/items/
+```
+
+इस पर जाने जैसा ही होगा:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+लेकिन अगर आप, उदाहरण के लिए, इस पर जाते हैं:
+
+```
+http://127.0.0.1:8000/items/?skip=20
+```
+
+तो आपके function में parameter values होंगी:
+
+* `skip=20`: क्योंकि आपने इसे URL में सेट किया है
+* `limit=10`: क्योंकि वह default value था
+
+## Optional parameters { #optional-parameters }
+
+उसी तरह, आप optional query parameters declare कर सकते हैं, उनका default `None` सेट करके:
+
+{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
+
+इस मामले में, function parameter `q` optional होगा, और default रूप से `None` होगा।
+
+/// tip | सुझाव
+
+यह भी ध्यान दें कि **FastAPI** इतना smart है कि यह पहचान लेता है कि path parameter `item_id` एक path parameter है और `q` नहीं है, इसलिए, यह एक query parameter है।
+
+///
+
+## Query parameter type conversion { #query-parameter-type-conversion }
+
+आप `bool` types भी declare कर सकते हैं, और वे convert हो जाएँगे:
+
+{* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
+
+इस मामले में, अगर आप इस पर जाते हैं:
+
+```
+http://127.0.0.1:8000/items/foo?short=1
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=True
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=true
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=on
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=yes
+```
+
+या कोई भी दूसरी case variation (uppercase, पहले अक्षर को uppercase, आदि), आपका function parameter `short` को `True` के `bool` value के साथ देखेगा। अन्यथा `False` के रूप में।
+
+
+## कई path और query parameters { #multiple-path-and-query-parameters }
+
+आप एक ही समय में कई path parameters और query parameters declare कर सकते हैं, **FastAPI** जानता है कि कौन सा कौन है।
+
+और आपको उन्हें किसी विशेष order में declare करने की ज़रूरत नहीं है।
+
+उन्हें नाम से detect किया जाएगा:
+
+{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
+
+## Required query parameters { #required-query-parameters }
+
+जब आप non-path parameters के लिए default value declare करते हैं (अभी तक, हमने केवल query parameters देखे हैं), तो वह required नहीं होता।
+
+अगर आप कोई specific value नहीं जोड़ना चाहते लेकिन बस उसे optional बनाना चाहते हैं, तो default को `None` के रूप में सेट करें।
+
+लेकिन जब आप किसी query parameter को required बनाना चाहते हैं, तो आप बस कोई default value declare न करें:
+
+{* ../../docs_src/query_params/tutorial005_py310.py hl[6:7] *}
+
+यहाँ query parameter `needy` type `str` का एक required query parameter है।
+
+अगर आप अपने browser में इस तरह का URL खोलते हैं:
+
+```
+http://127.0.0.1:8000/items/foo-item
+```
+
+...required parameter `needy` जोड़े बिना, तो आपको इस तरह की error दिखाई देगी:
+
+```JSON
+{
+  "detail": [
+    {
+      "type": "missing",
+      "loc": [
+        "query",
+        "needy"
+      ],
+      "msg": "Field required",
+      "input": null
+    }
+  ]
+}
+```
+
+क्योंकि `needy` एक required parameter है, आपको इसे URL में सेट करना होगा:
+
+```
+http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
+```
+
+...यह काम करेगा:
+
+```JSON
+{
+    "item_id": "foo-item",
+    "needy": "sooooneedy"
+}
+```
+
+और निश्चित रूप से, आप कुछ parameters को required, कुछ को default value वाला, और कुछ को पूरी तरह optional define कर सकते हैं:
+
+{* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
+
+इस मामले में, 3 query parameters हैं:
+
+* `needy`, एक required `str`.
+* `skip`, default value `0` के साथ एक `int`.
+* `limit`, एक optional `int`.
+
+/// tip | सुझाव
+
+आप `Enum`s को भी उसी तरह use कर सकते हैं जैसे [Path Parameters](path-params.md#predefined-values) के साथ।
+
+///

docs/hi/docs/tutorial/request-files.md

@@ -0,0 +1,176 @@
+# Request Files { #request-files }
+
+आप client द्वारा अपलोड की जाने वाली files को `File` का उपयोग करके परिभाषित कर सकते हैं।
+
+/// note | नोट
+
+अपलोड की गई files प्राप्त करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install python-multipart
+```
+
+ऐसा इसलिए है क्योंकि अपलोड की गई files "form data" के रूप में भेजी जाती हैं।
+
+///
+
+## `File` Import करें { #import-file }
+
+`fastapi` से `File` और `UploadFile` import करें:
+
+{* ../../docs_src/request_files/tutorial001_an_py310.py hl[3] *}
+
+## `File` Parameters परिभाषित करें { #define-file-parameters }
+
+file parameters उसी तरह बनाएं जैसे आप `Body` या `Form` के लिए बनाते हैं:
+
+{* ../../docs_src/request_files/tutorial001_an_py310.py hl[9] *}
+
+/// note | नोट
+
+`File` एक class है जो सीधे `Form` से inherit करती है।
+
+लेकिन याद रखें कि जब आप `fastapi` से `Query`, `Path`, `File` और अन्य import करते हैं, तो वे वास्तव में functions होते हैं जो विशेष classes return करते हैं।
+
+///
+
+/// tip | सुझाव
+
+File bodies घोषित करने के लिए, आपको `File` का उपयोग करना होगा, क्योंकि अन्यथा parameters को query parameters या body (JSON) parameters के रूप में समझा जाएगा।
+
+///
+
+files "form data" के रूप में अपलोड की जाएंगी।
+
+यदि आप अपने *path operation function* parameter का type `bytes` के रूप में घोषित करते हैं, तो **FastAPI** आपके लिए file पढ़ेगा और आपको सामग्री `bytes` के रूप में प्राप्त होगी।
+
+ध्यान रखें कि इसका मतलब है कि पूरी सामग्री memory में संग्रहीत होगी। यह छोटी files के लिए अच्छी तरह काम करेगा।
+
+लेकिन कई मामलों में आपको `UploadFile` का उपयोग करने से लाभ हो सकता है।
+
+## `UploadFile` के साथ File Parameters { #file-parameters-with-uploadfile }
+
+`UploadFile` type के साथ file parameter परिभाषित करें:
+
+{* ../../docs_src/request_files/tutorial001_an_py310.py hl[14] *}
+
+`bytes` की तुलना में `UploadFile` का उपयोग करने के कई फायदे हैं:
+
+* आपको parameter के default value में `File()` का उपयोग नहीं करना पड़ता।
+* यह एक "spooled" file का उपयोग करता है:
+    * एक file जो अधिकतम size limit तक memory में संग्रहीत होती है, और इस limit को पार करने के बाद disk पर संग्रहीत होती है।
+* इसका मतलब है कि यह images, videos, बड़े binaries आदि जैसी बड़ी files के लिए सारी memory का उपयोग किए बिना अच्छी तरह काम करेगा।
+* आप अपलोड की गई file से metadata प्राप्त कर सकते हैं।
+* इसमें [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) `async` interface है।
+* यह एक वास्तविक Python [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) object expose करता है जिसे आप सीधे अन्य libraries को पास कर सकते हैं जो file-like object की अपेक्षा करती हैं।
+
+### `UploadFile` { #uploadfile }
+
+`UploadFile` में निम्नलिखित attributes होते हैं:
+
+* `filename`: मूल file name के साथ एक `str` जो अपलोड किया गया था (जैसे `myimage.jpg`)।
+* `content_type`: content type (MIME type / media type) के साथ एक `str` (जैसे `image/jpeg`)।
+* `file`: एक [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) (एक [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) object)। यह वास्तविक Python file object है जिसे आप सीधे अन्य functions या libraries को पास कर सकते हैं जो "file-like" object की अपेक्षा करती हैं।
+
+`UploadFile` में निम्नलिखित `async` methods होते हैं। ये सभी अंदर से संबंधित file methods को call करते हैं (internal `SpooledTemporaryFile` का उपयोग करके)।
+
+* `write(data)`: `data` (`str` या `bytes`) को file में लिखता है।
+* `read(size)`: file के `size` (`int`) bytes/characters पढ़ता है।
+* `seek(offset)`: file में byte position `offset` (`int`) पर जाता है।
+    * उदाहरण के लिए, `await myfile.seek(0)` file की शुरुआत पर जाएगा।
+    * यह विशेष रूप से तब उपयोगी है जब आप एक बार `await myfile.read()` चलाते हैं और फिर सामग्री को दोबारा पढ़ने की आवश्यकता होती है।
+* `close()`: file को बंद करता है।
+
+क्योंकि ये सभी methods `async` methods हैं, आपको उन्हें "await" करना होगा।
+
+उदाहरण के लिए, एक `async` *path operation function* के अंदर आप सामग्री इस तरह प्राप्त कर सकते हैं:
+
+```Python
+contents = await myfile.read()
+```
+
+यदि आप एक सामान्य `def` *path operation function* के अंदर हैं, तो आप सीधे `UploadFile.file` access कर सकते हैं, उदाहरण के लिए:
+
+```Python
+contents = myfile.file.read()
+```
+
+/// note | `async` तकनीकी विवरण
+
+जब आप `async` methods का उपयोग करते हैं, तो **FastAPI** file methods को threadpool में चलाता है और उनके लिए await करता है।
+
+///
+
+/// note | Starlette तकनीकी विवरण
+
+**FastAPI** का `UploadFile` सीधे **Starlette** के `UploadFile` से inherit करता है, लेकिन **Pydantic** और FastAPI के अन्य भागों के साथ इसे compatible बनाने के लिए कुछ आवश्यक हिस्से जोड़ता है।
+
+///
+
+## "Form Data" क्या है { #what-is-form-data }
+
+HTML forms (`<form></form>`) सामान्यतः data को server पर भेजने के लिए उस data के लिए एक "special" encoding का उपयोग करते हैं, यह JSON से अलग होता है।
+
+**FastAPI** यह सुनिश्चित करेगा कि उस data को JSON के बजाय सही जगह से पढ़ा जाए।
+
+/// note | तकनीकी विवरण
+
+forms से data सामान्यतः "media type" `application/x-www-form-urlencoded` का उपयोग करके encoded होता है जब इसमें files शामिल नहीं होतीं।
+
+लेकिन जब form में files शामिल होती हैं, तो यह `multipart/form-data` के रूप में encoded होता है। यदि आप `File` का उपयोग करते हैं, तो **FastAPI** जान जाएगा कि उसे body के सही भाग से files प्राप्त करनी हैं।
+
+यदि आप इन encodings और form fields के बारे में अधिक पढ़ना चाहते हैं, तो [`POST` के लिए <abbr title="Mozilla Developer Network - मोज़िला डेवलपर नेटवर्क">MDN</abbr> web docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) पर जाएं।
+
+///
+
+/// warning | चेतावनी
+
+आप एक *path operation* में कई `File` और `Form` parameters घोषित कर सकते हैं, लेकिन आप ऐसे `Body` fields भी घोषित नहीं कर सकते जिन्हें आप JSON के रूप में प्राप्त करने की अपेक्षा करते हैं, क्योंकि request में body `application/json` के बजाय `multipart/form-data` का उपयोग करके encoded होगी।
+
+यह **FastAPI** की limitation नहीं है, यह HTTP protocol का हिस्सा है।
+
+///
+
+## Optional File Upload { #optional-file-upload }
+
+आप standard type annotations का उपयोग करके और default value `None` set करके file को optional बना सकते हैं:
+
+{* ../../docs_src/request_files/tutorial001_02_an_py310.py hl[9,17] *}
+
+## अतिरिक्त Metadata के साथ `UploadFile` { #uploadfile-with-additional-metadata }
+
+आप `UploadFile` के साथ `File()` का भी उपयोग कर सकते हैं, उदाहरण के लिए, अतिरिक्त metadata set करने के लिए:
+
+{* ../../docs_src/request_files/tutorial001_03_an_py310.py hl[9,15] *}
+
+## Multiple File Uploads { #multiple-file-uploads }
+
+एक ही समय में कई files अपलोड करना संभव है।
+
+वे "form data" का उपयोग करके भेजे गए उसी "form field" से संबंधित होंगी।
+
+इसका उपयोग करने के लिए, `bytes` या `UploadFile` की list घोषित करें:
+
+{* ../../docs_src/request_files/tutorial002_an_py310.py hl[10,15] *}
+
+आपको, जैसा घोषित किया गया है, `bytes` या `UploadFile`s की एक `list` प्राप्त होगी।
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import HTMLResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.responses` को `fastapi.responses` के रूप में प्रदान करता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+///
+
+### अतिरिक्त Metadata के साथ Multiple File Uploads { #multiple-file-uploads-with-additional-metadata }
+
+और पहले की तरह ही, आप अतिरिक्त parameters set करने के लिए `File()` का उपयोग कर सकते हैं, यहां तक कि `UploadFile` के लिए भी:
+
+{* ../../docs_src/request_files/tutorial003_an_py310.py hl[11,18:20] *}
+
+## Recap { #recap }
+
+request में अपलोड की जाने वाली files घोषित करने के लिए `File`, `bytes`, और `UploadFile` का उपयोग करें, जिन्हें form data के रूप में भेजा जाता है।

docs/hi/docs/tutorial/request-form-models.md

@@ -0,0 +1,78 @@
+# Form Models { #form-models }
+
+आप FastAPI में **form fields** declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं।
+
+/// note | नोट
+
+forms का उपयोग करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install python-multipart
+```
+
+///
+
+/// note | नोट
+
+यह FastAPI version `0.113.0` से supported है। 🤓
+
+///
+
+## Forms के लिए Pydantic Models { #pydantic-models-for-forms }
+
+आपको बस उन fields के साथ एक **Pydantic model** declare करना है जिन्हें आप **form fields** के रूप में receive करना चाहते हैं, और फिर parameter को `Form` के रूप में declare करना है:
+
+{* ../../docs_src/request_form_models/tutorial001_an_py310.py hl[9:11,15] *}
+
+**FastAPI** request में मौजूद **form data** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs जाँचें { #check-the-docs }
+
+आप इसे `/docs` पर docs UI में verify कर सकते हैं:
+
+<div class="screenshot">
+<img src="/img/tutorial/request-form-models/image01.png">
+</div>
+
+## Extra Form Fields को मना करें { #forbid-extra-form-fields }
+
+कुछ खास use cases में (शायद बहुत आम नहीं), आप form fields को केवल उन तक **restrict** करना चाह सकते हैं जो Pydantic model में declare किए गए हैं। और किसी भी **extra** fields को **forbid** करना चाह सकते हैं।
+
+/// note | नोट
+
+यह FastAPI version `0.114.0` से supported है। 🤓
+
+///
+
+आप किसी भी `extra` fields को `forbid` करने के लिए Pydantic की model configuration का उपयोग कर सकते हैं:
+
+{* ../../docs_src/request_form_models/tutorial002_an_py310.py hl[12] *}
+
+अगर कोई client कुछ extra data भेजने की कोशिश करता है, तो उन्हें एक **error** response मिलेगा।
+
+उदाहरण के लिए, अगर client ये form fields भेजने की कोशिश करता है:
+
+* `username`: `Rick`
+* `password`: `Portal Gun`
+* `extra`: `Mr. Poopybutthole`
+
+तो उन्हें एक error response मिलेगा जो बताएगा कि field `extra` allowed नहीं है:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["body", "extra"],
+            "msg": "Extra inputs are not permitted",
+            "input": "Mr. Poopybutthole"
+        }
+    ]
+}
+```
+
+## सारांश { #summary }
+
+आप FastAPI में form fields declare करने के लिए Pydantic models का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/request-forms-and-files.md

@@ -0,0 +1,41 @@
+# Request Forms और Files { #request-forms-and-files }
+
+आप `File` और `Form` का उपयोग करके files और form fields को एक ही समय में define कर सकते हैं।
+
+/// note | नोट
+
+अपलोड की गई files और/या form data प्राप्त करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर इसे install करें, उदाहरण के लिए:
+
+```console
+$ pip install python-multipart
+```
+
+///
+
+## `File` और `Form` Import करें { #import-file-and-form }
+
+{* ../../docs_src/request_forms_and_files/tutorial001_an_py310.py hl[3] *}
+
+## `File` और `Form` parameters define करें { #define-file-and-form-parameters }
+
+file और form parameters उसी तरह बनाएँ जैसे आप `Body` या `Query` के लिए बनाते हैं:
+
+{* ../../docs_src/request_forms_and_files/tutorial001_an_py310.py hl[10:12] *}
+
+files और form fields, form data के रूप में अपलोड किए जाएँगे और आपको files और form fields प्राप्त होंगे।
+
+और आप कुछ files को `bytes` के रूप में और कुछ को `UploadFile` के रूप में declare कर सकते हैं।
+
+/// warning | चेतावनी
+
+आप एक *path operation* में कई `File` और `Form` parameters declare कर सकते हैं, लेकिन आप साथ ही ऐसे `Body` fields declare नहीं कर सकते जिन्हें आप JSON के रूप में प्राप्त करने की अपेक्षा करते हैं, क्योंकि request में body `application/json` के बजाय `multipart/form-data` का उपयोग करके encoded होगी।
+
+यह **FastAPI** की कोई सीमा नहीं है, यह HTTP protocol का हिस्सा है।
+
+///
+
+## Recap { #recap }
+
+जब आपको एक ही request में data और files प्राप्त करने की आवश्यकता हो, तो `File` और `Form` को साथ में उपयोग करें।

docs/hi/docs/tutorial/request-forms.md

@@ -0,0 +1,73 @@
+# Form Data { #form-data }
+
+जब आपको JSON के बजाय form fields प्राप्त करने हों, तो आप `Form` का उपयोग कर सकते हैं।
+
+/// note | नोट
+
+forms का उपयोग करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install python-multipart
+```
+
+///
+
+## `Form` Import करें { #import-form }
+
+`fastapi` से `Form` import करें:
+
+{* ../../docs_src/request_forms/tutorial001_an_py310.py hl[3] *}
+
+## `Form` parameters परिभाषित करें { #define-form-parameters }
+
+form parameters उसी तरह बनाएं जैसे आप `Body` या `Query` के लिए बनाते:
+
+{* ../../docs_src/request_forms/tutorial001_an_py310.py hl[9] *}
+
+उदाहरण के लिए, OAuth2 specification का उपयोग जिन तरीकों से किया जा सकता है उनमें से एक में (जिसे "password flow" कहा जाता है) `username` और `password` को form fields के रूप में भेजना required है।
+
+<dfn title="specification">spec</dfn> के अनुसार fields के नाम बिल्कुल `username` और `password` होने चाहिए, और उन्हें JSON नहीं, बल्कि form fields के रूप में भेजा जाना चाहिए।
+
+`Form` के साथ आप वही configurations declare कर सकते हैं जो `Body` (और `Query`, `Path`, `Cookie`) के साथ करते हैं, जिसमें validation, examples, alias (जैसे `username` के बजाय `user-name`), आदि शामिल हैं।
+
+/// note | नोट
+
+`Form` एक class है जो सीधे `Body` से inherit करती है।
+
+///
+
+/// tip | टिप
+
+form bodies declare करने के लिए, आपको स्पष्ट रूप से `Form` का उपयोग करना होगा, क्योंकि इसके बिना parameters को query parameters या body (JSON) parameters के रूप में समझा जाएगा।
+
+///
+
+## "Form Fields" के बारे में { #about-form-fields }
+
+HTML forms (`<form></form>`) आमतौर पर data को server पर भेजने के लिए उस data के लिए एक "special" encoding का उपयोग करते हैं, यह JSON से अलग होता है।
+
+**FastAPI** यह सुनिश्चित करेगा कि उस data को JSON के बजाय सही जगह से पढ़ा जाए।
+
+/// note | तकनीकी विवरण
+
+forms से आने वाला data आमतौर पर "media type" `application/x-www-form-urlencoded` का उपयोग करके encoded होता है।
+
+लेकिन जब form में files शामिल होती हैं, तो इसे `multipart/form-data` के रूप में encoded किया जाता है। files को handle करने के बारे में आप अगले chapter में पढ़ेंगे।
+
+अगर आप इन encodings और form fields के बारे में अधिक पढ़ना चाहते हैं, तो [`POST` के लिए <abbr title="Mozilla Developer Network - मोज़िला डेवलपर नेटवर्क">MDN</abbr> web docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) देखें।
+
+///
+
+/// warning | चेतावनी
+
+आप एक *path operation* में कई `Form` parameters declare कर सकते हैं, लेकिन आप साथ में ऐसे `Body` fields declare नहीं कर सकते जिन्हें आप JSON के रूप में प्राप्त करने की उम्मीद करते हैं, क्योंकि request में body `application/json` के बजाय `application/x-www-form-urlencoded` का उपयोग करके encoded होगी।
+
+यह **FastAPI** की limitation नहीं है, यह HTTP protocol का हिस्सा है।
+
+///
+
+## Recap { #recap }
+
+form data input parameters declare करने के लिए `Form` का उपयोग करें।

docs/hi/docs/tutorial/response-model.md

@@ -0,0 +1,344 @@
+# Response Model - Return Type { #response-model-return-type }
+
+आप response के लिए उपयोग किए जाने वाले type को *path operation function* के **return type** को annotate करके declare कर सकते हैं।
+
+आप **type annotations** का उपयोग उसी तरह कर सकते हैं जैसे आप function **parameters** में input data के लिए करते हैं, आप Pydantic models, lists, dictionaries, scalar values जैसे integers, booleans, आदि का उपयोग कर सकते हैं।
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
+
+FastAPI इस return type का उपयोग इनके लिए करेगा:
+
+* लौटाए गए data को **Validate** करना।
+    * अगर data invalid है (जैसे कि कोई field missing है), तो इसका मतलब है कि *आपके* app code में गड़बड़ी है, वह वह data return नहीं कर रहा जो उसे करना चाहिए, और यह incorrect data return करने के बजाय server error return करेगा। इस तरह आप और आपके clients सुनिश्चित हो सकते हैं कि उन्हें expected data और data shape मिलेगा।
+* OpenAPI *path operation* में response के लिए एक **JSON Schema** जोड़ना।
+    * इसका उपयोग **automatic docs** द्वारा किया जाएगा।
+    * इसका उपयोग automatic client code generation tools द्वारा भी किया जाएगा।
+* Pydantic का उपयोग करके लौटाए गए data को JSON में **Serialize** करना, जो **Rust** में लिखा गया है, इसलिए यह **बहुत तेज़** होगा।
+
+लेकिन सबसे महत्वपूर्ण:
+
+* यह output data को return type में defined data तक **limit और filter** करेगा।
+    * यह **security** के लिए विशेष रूप से महत्वपूर्ण है, हम नीचे इसका और अधिक देखेंगे।
+
+## `response_model` Parameter { #response-model-parameter }
+
+कुछ cases ऐसे होते हैं जहाँ आपको ऐसा data return करना होता है या आप ऐसा करना चाहते हैं जो type द्वारा declare किए गए data से बिल्कुल मेल नहीं खाता।
+
+उदाहरण के लिए, आप **dictionary return** करना या database object return करना चाह सकते हैं, लेकिन **उसे Pydantic model के रूप में declare** करना चाह सकते हैं। इस तरह Pydantic model आपके द्वारा लौटाए गए object (जैसे dictionary या database object) के लिए सभी data documentation, validation, आदि करेगा।
+
+अगर आपने return type annotation जोड़ा, तो tools और editors एक (सही) error के साथ शिकायत करेंगे कि आपका function ऐसा type (जैसे dict) return कर रहा है जो आपके द्वारा declare किए गए type (जैसे Pydantic model) से अलग है।
+
+ऐसे cases में, आप return type के बजाय *path operation decorator* parameter `response_model` का उपयोग कर सकते हैं।
+
+आप किसी भी *path operations* में `response_model` parameter का उपयोग कर सकते हैं:
+
+* `@app.get()`
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+* आदि।
+
+{* ../../docs_src/response_model/tutorial001_py310.py hl[17,22,24:27] *}
+
+/// note | नोट
+
+ध्यान दें कि `response_model` "decorator" method (`get`, `post`, आदि) का parameter है। यह आपके *path operation function* का parameter नहीं है, जैसे सभी parameters और body होते हैं।
+
+///
+
+`response_model` वही type receive करता है जिसे आप Pydantic model field के लिए declare करेंगे, इसलिए यह Pydantic model हो सकता है, लेकिन यह, जैसे कि `List[Item]` की तरह Pydantic models की `list` भी हो सकता है।
+
+FastAPI इस `response_model` का उपयोग सभी data documentation, validation, आदि के लिए करेगा और output data को इसके type declaration में **convert और filter** भी करेगा।
+
+/// tip | सुझाव
+
+अगर आपके editor, mypy, आदि में strict type checks हैं, तो आप function return type को `Any` के रूप में declare कर सकते हैं।
+
+इस तरह आप editor को बताते हैं कि आप जानबूझकर कुछ भी return कर रहे हैं। लेकिन FastAPI फिर भी `response_model` के साथ data documentation, validation, filtering, आदि करेगा।
+
+///
+
+### `response_model` Priority { #response-model-priority }
+
+अगर आप return type और `response_model` दोनों declare करते हैं, तो `response_model` को priority मिलेगी और FastAPI द्वारा इसका उपयोग किया जाएगा।
+
+इस तरह आप अपने functions में सही type annotations जोड़ सकते हैं, भले ही आप response model से अलग type return कर रहे हों, ताकि editor और mypy जैसे tools उनका उपयोग कर सकें। और फिर भी FastAPI `response_model` का उपयोग करके data validation, documentation, आदि कर सकता है।
+
+आप उस *path operation* के लिए response model बनाना disable करने के लिए `response_model=None` का भी उपयोग कर सकते हैं, आपको ऐसा तब करना पड़ सकता है जब आप उन चीज़ों के लिए type annotations जोड़ रहे हों जो valid Pydantic fields नहीं हैं, आप नीचे के sections में से एक में इसका उदाहरण देखेंगे।
+
+## वही input data return करें { #return-the-same-input-data }
+
+यहाँ हम एक `UserIn` model declare कर रहे हैं, इसमें plaintext password होगा:
+
+{* ../../docs_src/response_model/tutorial002_py310.py hl[7,9] *}
+
+/// note | नोट
+
+`EmailStr` का उपयोग करने के लिए, पहले [`email-validator`](https://github.com/JoshData/python-email-validator) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install email-validator
+```
+
+या इसके साथ:
+
+```console
+$ pip install "pydantic[email]"
+```
+
+///
+
+और हम इस model का उपयोग अपने input को declare करने और उसी model का उपयोग अपने output को declare करने के लिए कर रहे हैं:
+
+{* ../../docs_src/response_model/tutorial002_py310.py hl[16] *}
+
+अब, जब भी कोई browser password के साथ user बना रहा होगा, API response में वही password return करेगी।
+
+इस case में, यह problem नहीं हो सकती, क्योंकि password भेजने वाला वही user है।
+
+लेकिन अगर हम उसी model का उपयोग किसी और *path operation* के लिए करते हैं, तो हम अपने user के passwords हर client को भेज सकते हैं।
+
+/// danger | खतरा
+
+कभी भी किसी user का plain password store न करें या उसे इस तरह response में न भेजें, जब तक कि आप सभी caveats नहीं जानते और यह नहीं जानते कि आप क्या कर रहे हैं।
+
+///
+
+## Output model जोड़ें { #add-an-output-model }
+
+इसके बजाय हम plaintext password के साथ एक input model और उसके बिना एक output model बना सकते हैं:
+
+{* ../../docs_src/response_model/tutorial003_py310.py hl[9,11,16] *}
+
+यहाँ, भले ही हमारा *path operation function* वही input user return कर रहा है जिसमें password शामिल है:
+
+{* ../../docs_src/response_model/tutorial003_py310.py hl[24] *}
+
+...हमने `response_model` को अपना model `UserOut` declare किया है, जिसमें password शामिल नहीं है:
+
+{* ../../docs_src/response_model/tutorial003_py310.py hl[22] *}
+
+इसलिए, **FastAPI** output model में declare न किए गए सभी data को filter out करने का ध्यान रखेगा (Pydantic का उपयोग करके)।
+
+### `response_model` या Return Type { #response-model-or-return-type }
+
+इस case में, क्योंकि दोनों models अलग हैं, अगर हमने function return type को `UserOut` के रूप में annotate किया, तो editor और tools शिकायत करेंगे कि हम invalid type return कर रहे हैं, क्योंकि वे अलग classes हैं।
+
+इसीलिए इस उदाहरण में हमें इसे `response_model` parameter में declare करना पड़ता है।
+
+...लेकिन इसे कैसे overcome किया जाए, यह देखने के लिए नीचे पढ़ना जारी रखें।
+
+## Return Type और Data Filtering { #return-type-and-data-filtering }
+
+आइए पिछले उदाहरण से आगे बढ़ते हैं। हम **function को एक type के साथ annotate** करना चाहते थे, लेकिन हम function से ऐसा कुछ return कर पाना चाहते थे जिसमें वास्तव में **अधिक data** शामिल हो।
+
+हम चाहते हैं कि FastAPI response model का उपयोग करके data को **filter** करता रहे। ताकि भले ही function अधिक data return करे, response में केवल वही fields शामिल हों जो response model में declare किए गए हैं।
+
+पिछले उदाहरण में, क्योंकि classes अलग थीं, हमें `response_model` parameter का उपयोग करना पड़ा। लेकिन इसका मतलब यह भी है कि हमें function return type check करने वाले editor और tools से support नहीं मिलता।
+
+लेकिन अधिकतर cases में जहाँ हमें ऐसा कुछ करना होता है, हम चाहते हैं कि model बस इस उदाहरण की तरह कुछ data को **filter/remove** करे।
+
+और उन cases में, हम classes और inheritance का उपयोग करके function **type annotations** का लाभ उठा सकते हैं ताकि editor और tools में बेहतर support मिले, और फिर भी FastAPI **data filtering** मिल सके।
+
+{* ../../docs_src/response_model/tutorial003_01_py310.py hl[7:10,13:14,18] *}
+
+इसके साथ, हमें editors और mypy से tooling support मिलता है क्योंकि यह code types के संदर्भ में सही है, लेकिन हमें FastAPI से data filtering भी मिलती है।
+
+यह कैसे काम करता है? आइए इसे देखें। 🤓
+
+### Type Annotations और Tooling { #type-annotations-and-tooling }
+
+पहले देखते हैं कि editors, mypy और अन्य tools इसे कैसे देखेंगे।
+
+`BaseUser` में base fields हैं। फिर `UserIn`, `BaseUser` से inherit करता है और `password` field जोड़ता है, इसलिए इसमें दोनों models के सभी fields शामिल होंगे।
+
+हम function return type को `BaseUser` के रूप में annotate करते हैं, लेकिन वास्तव में हम `UserIn` instance return कर रहे हैं।
+
+Editor, mypy, और अन्य tools इस पर शिकायत नहीं करेंगे क्योंकि typing terms में, `UserIn`, `BaseUser` का subclass है, जिसका मतलब है कि जब expected कुछ भी `BaseUser` हो, तो यह एक *valid* type है।
+
+### FastAPI Data Filtering { #fastapi-data-filtering }
+
+अब, FastAPI के लिए, यह return type देखेगा और सुनिश्चित करेगा कि आप जो return करते हैं उसमें **केवल** वही fields शामिल हों जो type में declare किए गए हैं।
+
+FastAPI internally Pydantic के साथ कई चीज़ें करता है ताकि यह सुनिश्चित हो सके कि class inheritance के वही rules returned data filtering के लिए उपयोग न किए जाएँ, नहीं तो आप expected से कहीं अधिक data return कर सकते हैं।
+
+इस तरह, आप दोनों दुनिया का best पा सकते हैं: **tooling support** के साथ type annotations और **data filtering**।
+
+## इसे docs में देखें { #see-it-in-the-docs }
+
+जब आप automatic docs देखते हैं, तो आप check कर सकते हैं कि input model और output model दोनों का अपना JSON Schema होगा:
+
+<img src="/img/tutorial/response-model/image01.png">
+
+और दोनों models interactive API documentation के लिए उपयोग किए जाएँगे:
+
+<img src="/img/tutorial/response-model/image02.png">
+
+## अन्य Return Type Annotations { #other-return-type-annotations }
+
+ऐसे cases हो सकते हैं जहाँ आप कुछ ऐसा return करते हैं जो valid Pydantic field नहीं है और आप उसे function में annotate करते हैं, केवल tooling (editor, mypy, आदि) द्वारा दिए गए support को पाने के लिए।
+
+### सीधे Response Return करें { #return-a-response-directly }
+
+सबसे common case होगा [advanced docs में बाद में समझाए अनुसार सीधे Response return करना](../advanced/response-directly.md)।
+
+{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
+
+यह simple case FastAPI द्वारा automatically handle किया जाता है क्योंकि return type annotation `Response` class (या उसका subclass) है।
+
+और tools भी खुश होंगे क्योंकि `RedirectResponse` और `JSONResponse` दोनों `Response` के subclasses हैं, इसलिए type annotation सही है।
+
+### Response Subclass Annotate करें { #annotate-a-response-subclass }
+
+आप type annotation में `Response` के subclass का भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/response_model/tutorial003_03_py310.py hl[8:9] *}
+
+यह भी काम करेगा क्योंकि `RedirectResponse`, `Response` का subclass है, और FastAPI इस simple case को automatically handle करेगा।
+
+### Invalid Return Type Annotations { #invalid-return-type-annotations }
+
+लेकिन जब आप कोई अन्य arbitrary object return करते हैं जो valid Pydantic type नहीं है (जैसे database object) और आप उसे function में उसी तरह annotate करते हैं, तो FastAPI उस type annotation से Pydantic response model बनाने की कोशिश करेगा, और fail हो जाएगा।
+
+ऐसा ही होगा अगर आपके पास अलग-अलग types के बीच <dfn title='कई types के बीच union का मतलब है "इनमें से कोई भी type".'>union</dfn> जैसा कुछ हो जहाँ उनमें से एक या अधिक valid Pydantic types नहीं हैं, उदाहरण के लिए यह fail होगा 💥:
+
+{* ../../docs_src/response_model/tutorial003_04_py310.py hl[8] *}
+
+...यह fail होता है क्योंकि type annotation Pydantic type नहीं है और केवल एक single `Response` class या subclass भी नहीं है, यह `Response` और `dict` के बीच union (दोनों में से कोई भी) है।
+
+### Response Model Disable करें { #disable-response-model }
+
+ऊपर दिए गए उदाहरण से आगे बढ़ते हुए, आप शायद default data validation, documentation, filtering, आदि नहीं चाहते हों जो FastAPI द्वारा किया जाता है।
+
+लेकिन आप शायद function में return type annotation फिर भी रखना चाहते हों ताकि editors और type checkers (जैसे mypy) जैसे tools से support मिल सके।
+
+इस case में, आप `response_model=None` set करके response model generation disable कर सकते हैं:
+
+{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}
+
+इससे FastAPI response model generation skip कर देगा और इस तरह आप अपनी जरूरत के किसी भी return type annotations का उपयोग कर सकते हैं, बिना इसके कि वह आपकी FastAPI application को प्रभावित करे। 🤓
+
+## Response Model encoding parameters { #response-model-encoding-parameters }
+
+आपके response model में default values हो सकते हैं, जैसे:
+
+{* ../../docs_src/response_model/tutorial004_py310.py hl[9,11:12] *}
+
+* `description: Union[str, None] = None` (या Python 3.10 में `str | None = None`) का default `None` है।
+* `tax: float = 10.5` का default `10.5` है।
+* `tags: List[str] = []` का default खाली list है: `[]`।
+
+लेकिन अगर वे वास्तव में store नहीं किए गए थे तो आप उन्हें result से omit करना चाह सकते हैं।
+
+उदाहरण के लिए, अगर आपके पास NoSQL database में कई optional attributes वाले models हैं, लेकिन आप default values से भरे बहुत लंबे JSON responses नहीं भेजना चाहते।
+
+### `response_model_exclude_unset` parameter का उपयोग करें { #use-the-response-model-exclude-unset-parameter }
+
+आप *path operation decorator* parameter `response_model_exclude_unset=True` set कर सकते हैं:
+
+{* ../../docs_src/response_model/tutorial004_py310.py hl[22] *}
+
+और वे default values response में शामिल नहीं होंगे, केवल वास्तव में set किए गए values ही शामिल होंगे।
+
+तो, अगर आप ID `foo` वाले item के लिए उस *path operation* को request भेजते हैं, तो response (default values शामिल किए बिना) होगा:
+
+```JSON
+{
+    "name": "Foo",
+    "price": 50.2
+}
+```
+
+/// note | नोट
+
+आप इसका भी उपयोग कर सकते हैं:
+
+* `response_model_exclude_defaults=True`
+* `response_model_exclude_none=True`
+
+जैसा कि `exclude_defaults` और `exclude_none` के लिए [Pydantic docs](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) में बताया गया है।
+
+///
+
+#### Defaults वाले fields के लिए values वाला data { #data-with-values-for-fields-with-defaults }
+
+लेकिन अगर आपके data में model के default values वाले fields के लिए values हैं, जैसे ID `bar` वाला item:
+
+```Python hl_lines="3  5"
+{
+    "name": "Bar",
+    "description": "The bartenders",
+    "price": 62,
+    "tax": 20.2
+}
+```
+
+तो वे response में शामिल होंगे।
+
+#### Defaults जैसे ही values वाला data { #data-with-the-same-values-as-the-defaults }
+
+अगर data में default values जैसे ही values हैं, जैसे ID `baz` वाला item:
+
+```Python hl_lines="3  5-6"
+{
+    "name": "Baz",
+    "description": None,
+    "price": 50.2,
+    "tax": 10.5,
+    "tags": []
+}
+```
+
+FastAPI इतना smart है (दरअसल, Pydantic इतना smart है) कि यह समझ सके कि, भले ही `description`, `tax`, और `tags` के values defaults जैसे ही हैं, उन्हें explicitly set किया गया था (defaults से लिए जाने के बजाय)।
+
+इसलिए, वे JSON response में शामिल होंगे।
+
+/// tip | सुझाव
+
+ध्यान दें कि default values कुछ भी हो सकते हैं, केवल `None` नहीं।
+
+वे list (`[]`), `10.5` का `float`, आदि हो सकते हैं।
+
+///
+
+### `response_model_include` और `response_model_exclude` { #response-model-include-and-response-model-exclude }
+
+आप *path operation decorator* parameters `response_model_include` और `response_model_exclude` का भी उपयोग कर सकते हैं।
+
+वे include करने के लिए attributes के नामों वाला `str` का `set` लेते हैं (बाकी को omit करते हुए) या exclude करने के लिए (बाकी को include करते हुए)।
+
+अगर आपके पास केवल एक Pydantic model है और आप output से कुछ data remove करना चाहते हैं, तो इसे quick shortcut के रूप में उपयोग किया जा सकता है।
+
+/// tip | सुझाव
+
+लेकिन फिर भी इन parameters के बजाय, multiple classes का उपयोग करते हुए, ऊपर दिए गए ideas का उपयोग करने की recommendation है।
+
+ऐसा इसलिए है क्योंकि आपके app के OpenAPI (और docs) में generated JSON Schema फिर भी complete model के लिए ही होगा, भले ही आप कुछ attributes omit करने के लिए `response_model_include` या `response_model_exclude` का उपयोग करें।
+
+यह `response_model_by_alias` पर भी लागू होता है जो इसी तरह काम करता है।
+
+///
+
+{* ../../docs_src/response_model/tutorial005_py310.py hl[29,35] *}
+
+/// tip | सुझाव
+
+Syntax `{"name", "description"}` उन दो values के साथ एक `set` बनाता है।
+
+यह `set(["name", "description"])` के equivalent है।
+
+///
+
+#### `set`s के बजाय `list`s का उपयोग करना { #using-lists-instead-of-sets }
+
+अगर आप `set` का उपयोग करना भूल जाते हैं और इसके बजाय `list` या `tuple` का उपयोग करते हैं, तो FastAPI फिर भी उसे `set` में convert कर देगा और यह सही तरह काम करेगा:
+
+{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}
+
+## Recap { #recap }
+
+Response models define करने और खासकर private data को filter out करना सुनिश्चित करने के लिए *path operation decorator* के parameter `response_model` का उपयोग करें।
+
+केवल explicitly set किए गए values return करने के लिए `response_model_exclude_unset` का उपयोग करें।

docs/hi/docs/tutorial/response-status-code.md

@@ -0,0 +1,101 @@
+# Response Status Code { #response-status-code }
+
+जिस तरह आप response model specify कर सकते हैं, उसी तरह आप किसी भी *path operations* में parameter `status_code` के साथ response के लिए इस्तेमाल किया जाने वाला HTTP status code भी declare कर सकते हैं:
+
+* `@app.get()`
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+* आदि।
+
+{* ../../docs_src/response_status_code/tutorial001_py310.py hl[6] *}
+
+/// note | नोट
+
+ध्यान दें कि `status_code`, "decorator" method (`get`, `post`, आदि) का parameter है। यह आपके *path operation function* का parameter नहीं है, जैसे बाकी सभी parameters और body होते हैं।
+
+///
+
+`status_code` parameter HTTP status code वाला एक number receive करता है।
+
+/// note | नोट
+
+`status_code` वैकल्पिक रूप से एक `IntEnum` भी receive कर सकता है, जैसे Python का [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus).
+
+///
+
+यह:
+
+* response में वह status code return करेगा।
+* उसे OpenAPI schema में उसी तरह document करेगा (और इसलिए, user interfaces में भी):
+
+<img src="/img/tutorial/response-status-code/image01.png">
+
+/// note | नोट
+
+कुछ response codes (अगला section देखें) यह indicate करते हैं कि response में body नहीं होती।
+
+FastAPI यह जानता है, और ऐसे OpenAPI docs बनाएगा जो बताते हैं कि कोई response body नहीं है।
+
+///
+
+## HTTP status codes के बारे में { #about-http-status-codes }
+
+/// note | नोट
+
+अगर आप पहले से जानते हैं कि HTTP status codes क्या होते हैं, तो अगले section पर जाएँ।
+
+///
+
+HTTP में, आप response के हिस्से के रूप में 3 digits का एक numeric status code भेजते हैं।
+
+इन status codes के साथ एक associated name होता है जिससे उन्हें पहचानने में मदद मिलती है, लेकिन महत्वपूर्ण हिस्सा number होता है।
+
+संक्षेप में:
+
+* `100 - 199` "Information" के लिए होते हैं। आप इन्हें सीधे बहुत कम इस्तेमाल करते हैं। इन status codes वाले responses में body नहीं हो सकती।
+* **`200 - 299`** "Successful" responses के लिए होते हैं। ये वे हैं जिन्हें आप सबसे ज़्यादा इस्तेमाल करेंगे।
+    * `200` default status code है, जिसका मतलब है कि सब कुछ "OK" था।
+    * एक और उदाहरण `201`, "Created" होगा। इसे आमतौर पर database में नया record बनाने के बाद इस्तेमाल किया जाता है।
+    * एक विशेष case `204`, "No Content" है। यह response तब इस्तेमाल होता है जब client को return करने के लिए कोई content नहीं होता, और इसलिए response में body नहीं होनी चाहिए।
+* **`300 - 399`** "Redirection" के लिए होते हैं। इन status codes वाले responses में body हो भी सकती है और नहीं भी, सिवाय `304`, "Not Modified" के, जिसमें body नहीं होनी चाहिए।
+* **`400 - 499`** "Client error" responses के लिए होते हैं। ये दूसरा type है जिसे आप शायद सबसे ज़्यादा इस्तेमाल करेंगे।
+    * एक उदाहरण `404` है, "Not Found" response के लिए।
+    * client से आने वाली generic errors के लिए, आप सिर्फ़ `400` इस्तेमाल कर सकते हैं।
+* `500 - 599` server errors के लिए होते हैं। आप इन्हें लगभग कभी सीधे इस्तेमाल नहीं करते। जब आपके application code या server के किसी हिस्से में कुछ गड़बड़ होती है, तो यह अपने-आप इन status codes में से एक return करेगा।
+
+/// tip | सुझाव
+
+हर status code के बारे में और कौन-सा code किसके लिए है, यह जानने के लिए [HTTP status codes के बारे में <abbr title="Mozilla Developer Network">MDN</abbr> documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) देखें।
+
+///
+
+## नाम याद रखने का shortcut { #shortcut-to-remember-the-names }
+
+आइए पिछले example को फिर से देखें:
+
+{* ../../docs_src/response_status_code/tutorial001_py310.py hl[6] *}
+
+`201` "Created" के लिए status code है।
+
+लेकिन आपको यह याद रखने की ज़रूरत नहीं है कि इनमें से हर code का क्या मतलब है।
+
+आप `fastapi.status` से convenience variables इस्तेमाल कर सकते हैं।
+
+{* ../../docs_src/response_status_code/tutorial002_py310.py hl[1,6] *}
+
+वे सिर्फ़ एक सुविधा हैं, उनमें वही number होता है, लेकिन इस तरह आप उन्हें खोजने के लिए editor के autocomplete का इस्तेमाल कर सकते हैं:
+
+<img src="/img/tutorial/response-status-code/image02.png">
+
+/// note | तकनीकी विवरण
+
+आप `from starlette import status` भी इस्तेमाल कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.status` `fastapi.status` के रूप में provide करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+## default बदलना { #changing-the-default }
+
+बाद में, [Advanced User Guide](../advanced/response-change-status-code.md) में, आप देखेंगे कि यहाँ declare किए जा रहे default से अलग status code कैसे return किया जाता है।

docs/hi/docs/tutorial/schema-extra-example.md

@@ -0,0 +1,202 @@
+# Request Example Data घोषित करें { #declare-request-example-data }
+
+आप उस data के examples घोषित कर सकते हैं जिसे आपका app receive कर सकता है।
+
+इसे करने के कई तरीके यहाँ दिए गए हैं।
+
+## Pydantic models में अतिरिक्त JSON Schema data { #extra-json-schema-data-in-pydantic-models }
+
+आप किसी Pydantic model के लिए `examples` घोषित कर सकते हैं, जिन्हें generated JSON Schema में जोड़ा जाएगा।
+
+{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
+
+वह अतिरिक्त जानकारी उस model के output **JSON Schema** में जैसी है वैसी ही जोड़ी जाएगी, और API docs में उपयोग की जाएगी।
+
+आप `model_config` attribute का उपयोग कर सकते हैं, जो एक `dict` लेता है, जैसा कि [Pydantic के docs: Configuration](https://docs.pydantic.dev/latest/api/config/) में बताया गया है।
+
+आप `"json_schema_extra"` को एक `dict` के साथ set कर सकते हैं जिसमें कोई भी अतिरिक्त data हो जिसे आप generated JSON Schema में दिखाना चाहते हैं, जिसमें `examples` भी शामिल हैं।
+
+/// tip | सुझाव
+
+आप इसी technique का उपयोग JSON Schema को extend करने और अपनी custom अतिरिक्त जानकारी जोड़ने के लिए कर सकते हैं।
+
+उदाहरण के लिए, आप इसका उपयोग frontend user interface आदि के लिए metadata जोड़ने में कर सकते हैं।
+
+///
+
+/// note | नोट
+
+OpenAPI 3.1.0 (FastAPI 0.99.0 से उपयोग किया गया) ने `examples` के लिए support जोड़ा, जो **JSON Schema** standard का हिस्सा है।
+
+उससे पहले, यह केवल keyword `example` को एक single example के साथ support करता था। यह अभी भी OpenAPI 3.1.0 द्वारा supported है, लेकिन deprecated है और JSON Schema standard का हिस्सा नहीं है। इसलिए आपको `example` से `examples` पर migrate करने के लिए प्रोत्साहित किया जाता है। 🤓
+
+आप इस page के अंत में और पढ़ सकते हैं।
+
+///
+
+## `Field` के अतिरिक्त arguments { #field-additional-arguments }
+
+Pydantic models के साथ `Field()` का उपयोग करते समय, आप अतिरिक्त `examples` भी घोषित कर सकते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial002_py310.py hl[2,8:11] *}
+
+## JSON Schema - OpenAPI में `examples` { #examples-in-json-schema-openapi }
+
+इनमें से किसी का भी उपयोग करते समय:
+
+* `Path()`
+* `Query()`
+* `Header()`
+* `Cookie()`
+* `Body()`
+* `Form()`
+* `File()`
+
+आप अतिरिक्त जानकारी के साथ `examples` का एक group भी घोषित कर सकते हैं, जिसे **OpenAPI** के अंदर उनके **JSON Schemas** में जोड़ा जाएगा।
+
+### `examples` के साथ `Body` { #body-with-examples }
+
+यहाँ हम `Body()` में अपेक्षित data के एक example वाला `examples` pass करते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial003_an_py310.py hl[22:29] *}
+
+### docs UI में Example { #example-in-the-docs-ui }
+
+ऊपर दिए गए किसी भी method के साथ यह `/docs` में इस तरह दिखेगा:
+
+<img src="/img/tutorial/body-fields/image01.png">
+
+### कई `examples` के साथ `Body` { #body-with-multiple-examples }
+
+बेशक आप कई `examples` भी pass कर सकते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial004_an_py310.py hl[23:38] *}
+
+जब आप ऐसा करते हैं, तो examples उस body data के internal **JSON Schema** का हिस्सा होंगे।
+
+फिर भी, <dfn title="2023-08-26">यह लिखते समय</dfn>, Swagger UI, वह tool जो docs UI दिखाने के लिए जिम्मेदार है, **JSON Schema** में data के लिए कई examples दिखाने को support नहीं करता। लेकिन workaround के लिए नीचे पढ़ें।
+
+### OpenAPI-specific `examples` { #openapi-specific-examples }
+
+**JSON Schema** द्वारा `examples` support किए जाने से पहले से ही, OpenAPI में एक अलग field के लिए support था जिसे `examples` भी कहा जाता था।
+
+यह **OpenAPI-specific** `examples` OpenAPI specification में किसी अन्य section में जाता है। यह प्रत्येक JSON Schema के अंदर नहीं, बल्कि **प्रत्येक *path operation* के details** में जाता है।
+
+और Swagger UI ने इस विशेष `examples` field को कुछ समय से support किया है। इसलिए, आप इसका उपयोग docs UI में अलग-अलग **examples दिखाने** के लिए कर सकते हैं।
+
+इस OpenAPI-specific field `examples` का आकार एक `dict` है जिसमें **कई examples** होते हैं (`list` के बजाय), और प्रत्येक में अतिरिक्त जानकारी होती है जो **OpenAPI** में भी जोड़ी जाएगी।
+
+यह OpenAPI में मौजूद प्रत्येक JSON Schema के अंदर नहीं जाता, यह बाहर, सीधे *path operation* में जाता है।
+
+### `openapi_examples` Parameter का उपयोग { #using-the-openapi-examples-parameter }
+
+आप FastAPI में OpenAPI-specific `examples` को parameter `openapi_examples` के साथ इनके लिए घोषित कर सकते हैं:
+
+* `Path()`
+* `Query()`
+* `Header()`
+* `Cookie()`
+* `Body()`
+* `Form()`
+* `File()`
+
+`dict` की keys प्रत्येक example की पहचान करती हैं, और प्रत्येक value एक और `dict` होती है।
+
+`examples` में प्रत्येक specific example `dict` में ये हो सकते हैं:
+
+* `summary`: example के लिए छोटा description।
+* `description`: एक लंबा description जिसमें Markdown text हो सकता है।
+* `value`: यह दिखाया गया वास्तविक example है, जैसे एक `dict`।
+* `externalValue`: `value` का alternative, example की ओर point करने वाला URL। हालांकि यह शायद `value` जितने tools द्वारा supported न हो।
+
+आप इसे इस तरह use कर सकते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial005_an_py310.py hl[23:49] *}
+
+### Docs UI में OpenAPI Examples { #openapi-examples-in-the-docs-ui }
+
+`Body()` में `openapi_examples` जोड़ने के साथ `/docs` इस तरह दिखेगा:
+
+<img src="/img/tutorial/body-fields/image02.png">
+
+## तकनीकी विवरण { #technical-details }
+
+/// tip | सुझाव
+
+यदि आप पहले से ही **FastAPI** version **0.99.0 या उससे ऊपर** का उपयोग कर रहे हैं, तो आप शायद ये details **skip** कर सकते हैं।
+
+ये पुराने versions के लिए अधिक relevant हैं, OpenAPI 3.1.0 उपलब्ध होने से पहले।
+
+आप इसे एक संक्षिप्त OpenAPI और JSON Schema **history lesson** मान सकते हैं। 🤓
+
+///
+
+/// warning | चेतावनी
+
+ये standards **JSON Schema** और **OpenAPI** के बारे में बहुत technical details हैं।
+
+यदि ऊपर दिए गए ideas आपके लिए पहले से ही काम कर रहे हैं, तो वह पर्याप्त हो सकता है, और शायद आपको इन details की जरूरत नहीं है, इन्हें skip करने के लिए स्वतंत्र महसूस करें।
+
+///
+
+OpenAPI 3.1.0 से पहले, OpenAPI ने **JSON Schema** के एक पुराने और modified version का उपयोग किया।
+
+JSON Schema में `examples` नहीं था, इसलिए OpenAPI ने अपने स्वयं के modified version में अपना `example` field जोड़ा।
+
+OpenAPI ने specification के अन्य हिस्सों में भी `example` और `examples` fields जोड़े:
+
+* [`Parameter Object` (specification में)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object) जिसका उपयोग FastAPI के इनसे किया गया:
+    * `Path()`
+    * `Query()`
+    * `Header()`
+    * `Cookie()`
+* [`Request Body Object`, field `content` में, `Media Type Object` पर (specification में)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object) जिसका उपयोग FastAPI के इनसे किया गया:
+    * `Body()`
+    * `File()`
+    * `Form()`
+
+/// note | नोट
+
+यह पुराना OpenAPI-specific `examples` parameter अब FastAPI `0.103.0` से `openapi_examples` है।
+
+///
+
+### JSON Schema का `examples` field { #json-schemas-examples-field }
+
+लेकिन फिर JSON Schema ने specification के एक नए version में एक [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5) field जोड़ा।
+
+और फिर नया OpenAPI 3.1.0 latest version (JSON Schema 2020-12) पर आधारित था, जिसमें यह नया field `examples` शामिल था।
+
+और अब यह नया `examples` field पुराने single (और custom) `example` field पर precedence लेता है, जो अब deprecated है।
+
+JSON Schema में यह नया `examples` field OpenAPI में अन्य जगहों (ऊपर वर्णित) की तरह अतिरिक्त metadata वाला dict नहीं है, यह **सिर्फ एक `list`** है।
+
+/// note | नोट
+
+OpenAPI 3.1.0 के JSON Schema के साथ इस नए सरल integration के साथ release होने के बाद भी, कुछ समय तक, Swagger UI, वह tool जो automatic docs प्रदान करता है, OpenAPI 3.1.0 को support नहीं करता था (यह version 5.0.0 से करता है 🎉)।
+
+इसी वजह से, 0.99.0 से पहले के FastAPI versions अभी भी OpenAPI के 3.1.0 से कम versions का उपयोग करते थे।
+
+///
+
+### Pydantic और FastAPI `examples` { #pydantic-and-fastapi-examples }
+
+जब आप Pydantic model के अंदर `examples` जोड़ते हैं, `schema_extra` या `Field(examples=["something"])` का उपयोग करके, तो वह example उस Pydantic model के **JSON Schema** में जोड़ा जाता है।
+
+और उस Pydantic model का **JSON Schema** आपकी API के **OpenAPI** में शामिल होता है, और फिर docs UI में उपयोग किया जाता है।
+
+FastAPI के 0.99.0 से पहले के versions में (0.99.0 और ऊपर वाले नए OpenAPI 3.1.0 का उपयोग करते हैं), जब आप किसी भी अन्य utilities (`Query()`, `Body()`, आदि) के साथ `example` या `examples` का उपयोग करते थे, तो वे examples उस data का वर्णन करने वाले JSON Schema में नहीं जोड़े जाते थे (OpenAPI के JSON Schema के अपने version में भी नहीं), वे सीधे OpenAPI में *path operation* declaration में जोड़े जाते थे (OpenAPI के उन parts के बाहर जो JSON Schema का उपयोग करते हैं)।
+
+लेकिन अब जबकि FastAPI 0.99.0 और ऊपर OpenAPI 3.1.0 का उपयोग करता है, जो JSON Schema 2020-12 का उपयोग करता है, और Swagger UI 5.0.0 और ऊपर, सब कुछ अधिक consistent है और examples JSON Schema में शामिल होते हैं।
+
+### Swagger UI और OpenAPI-specific `examples` { #swagger-ui-and-openapi-specific-examples }
+
+अब, क्योंकि Swagger UI कई JSON Schema examples को support नहीं करता था (2023-08-26 तक), users के पास docs में कई examples दिखाने का कोई तरीका नहीं था।
+
+इसे solve करने के लिए, FastAPI `0.103.0` ने नए parameter `openapi_examples` के साथ उसी पुराने **OpenAPI-specific** `examples` field को घोषित करने के लिए **support जोड़ा**। 🤓
+
+### Summary { #summary }
+
+मैं कहा करता था कि मुझे history उतनी पसंद नहीं है... और अब मुझे देखिए, "tech history" lessons दे रहा हूँ। 😅
+
+संक्षेप में, **FastAPI 0.99.0 या उससे ऊपर upgrade करें**, और चीजें बहुत अधिक **सरल, consistent, और intuitive** हैं, और आपको ये सारे historical details जानने की जरूरत नहीं है। 😎

docs/hi/docs/tutorial/security/simple-oauth2.md

@@ -0,0 +1,289 @@
+# Password और Bearer के साथ सरल OAuth2 { #simple-oauth2-with-password-and-bearer }
+
+अब पिछले अध्याय से आगे बढ़ते हैं और एक पूरा security flow बनाने के लिए छूटे हुए हिस्से जोड़ते हैं।
+
+## `username` और `password` प्राप्त करें { #get-the-username-and-password }
+
+हम `username` और `password` प्राप्त करने के लिए **FastAPI** security utilities का उपयोग करने वाले हैं।
+
+OAuth2 निर्दिष्ट करता है कि "password flow" (जिसका हम उपयोग कर रहे हैं) का उपयोग करते समय client/user को `username` और `password` fields को form data के रूप में भेजना होगा।
+
+और spec कहता है कि fields के नाम ऐसे ही होने चाहिए। इसलिए `user-name` या `email` काम नहीं करेगा।
+
+लेकिन चिंता न करें, frontend में आप इसे अपने अंतिम users को जैसे चाहें दिखा सकते हैं।
+
+और आपके database models कोई भी दूसरे नाम उपयोग कर सकते हैं जो आप चाहें।
+
+लेकिन login *path operation* के लिए, हमें spec के साथ compatible होने के लिए इन नामों का उपयोग करना होगा (और उदाहरण के लिए, integrated API documentation system का उपयोग कर पाने के लिए)।
+
+Spec यह भी बताता है कि `username` और `password` को form data के रूप में भेजा जाना चाहिए (इसलिए, यहाँ कोई JSON नहीं)।
+
+### `scope` { #scope }
+
+Spec यह भी कहता है कि client एक और form field "`scope`" भेज सकता है।
+
+form field का नाम `scope` है (singular में), लेकिन यह वास्तव में spaces से अलग किए गए "scopes" वाली एक लंबी string होती है।
+
+हर "scope" बस एक string है (बिना spaces के)।
+
+इनका सामान्यतः विशिष्ट security permissions घोषित करने के लिए उपयोग किया जाता है, उदाहरण के लिए:
+
+* `users:read` या `users:write` आम उदाहरण हैं।
+* `instagram_basic` Facebook / Instagram द्वारा उपयोग किया जाता है।
+* `https://www.googleapis.com/auth/drive` Google द्वारा उपयोग किया जाता है।
+
+/// note | नोट
+
+OAuth2 में "scope" बस एक string है जो किसी विशिष्ट required permission को घोषित करती है।
+
+इससे फर्क नहीं पड़ता कि उसमें `:` जैसे अन्य characters हैं या वह URL है।
+
+वे details implementation specific हैं।
+
+OAuth2 के लिए वे बस strings हैं।
+
+///
+
+## `username` और `password` प्राप्त करने का Code { #code-to-get-the-username-and-password }
+
+अब इसे संभालने के लिए **FastAPI** द्वारा प्रदान की गई utilities का उपयोग करते हैं।
+
+### `OAuth2PasswordRequestForm` { #oauth2passwordrequestform }
+
+पहले, `OAuth2PasswordRequestForm` import करें, और `/token` के *path operation* में `Depends` के साथ इसे dependency के रूप में उपयोग करें:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[4,78] *}
+
+`OAuth2PasswordRequestForm` एक class dependency है जो एक form body घोषित करती है जिसमें:
+
+* `username`।
+* `password`।
+* एक वैकल्पिक `scope` field, एक बड़ी string के रूप में, जो spaces से अलग की गई strings से बनी होती है।
+* एक वैकल्पिक `grant_type`।
+
+/// tip | टिप
+
+OAuth2 spec वास्तव में fixed value `password` के साथ एक field `grant_type` *required* करता है, लेकिन `OAuth2PasswordRequestForm` इसे enforce नहीं करता।
+
+अगर आपको इसे enforce करना है, तो `OAuth2PasswordRequestForm` की जगह `OAuth2PasswordRequestFormStrict` का उपयोग करें।
+
+///
+
+* एक वैकल्पिक `client_id` (हमारे उदाहरण के लिए हमें इसकी आवश्यकता नहीं है)।
+* एक वैकल्पिक `client_secret` (हमारे उदाहरण के लिए हमें इसकी आवश्यकता नहीं है)।
+
+/// note | नोट
+
+`OAuth2PasswordRequestForm`, **FastAPI** के लिए कोई विशेष class नहीं है जैसे `OAuth2PasswordBearer` है।
+
+`OAuth2PasswordBearer` **FastAPI** को बताता है कि यह एक security scheme है। इसलिए इसे OpenAPI में इस तरह जोड़ा जाता है।
+
+लेकिन `OAuth2PasswordRequestForm` बस एक class dependency है जिसे आप खुद भी लिख सकते थे, या आप सीधे `Form` parameters घोषित कर सकते थे।
+
+लेकिन क्योंकि यह एक सामान्य use case है, इसे आसान बनाने के लिए **FastAPI** द्वारा सीधे प्रदान किया गया है।
+
+///
+
+### form data का उपयोग करें { #use-the-form-data }
+
+/// tip | टिप
+
+dependency class `OAuth2PasswordRequestForm` के instance में spaces से अलग की गई लंबी string वाला attribute `scope` नहीं होगा, इसके बजाय, इसमें भेजे गए प्रत्येक scope के लिए actual strings की list वाला `scopes` attribute होगा।
+
+हम इस उदाहरण में `scopes` का उपयोग नहीं कर रहे हैं, लेकिन यदि आपको इसकी आवश्यकता हो तो functionality उपलब्ध है।
+
+///
+
+अब, form field से `username` का उपयोग करके (fake) database से user data प्राप्त करें।
+
+यदि ऐसा कोई user नहीं है, तो हम "Incorrect username or password" कहते हुए error लौटाते हैं।
+
+Error के लिए, हम exception `HTTPException` का उपयोग करते हैं:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[3,79:81] *}
+
+### password जाँचें { #check-the-password }
+
+इस समय हमारे पास database से user data है, लेकिन हमने password नहीं जाँचा है।
+
+पहले उस data को Pydantic `UserInDB` model में डालते हैं।
+
+आपको कभी भी plaintext passwords save नहीं करने चाहिए, इसलिए, हम (fake) password hashing system का उपयोग करेंगे।
+
+यदि passwords match नहीं करते, तो हम वही error लौटाते हैं।
+
+#### Password hashing { #password-hashing }
+
+"Hashing" का मतलब है: कुछ content (इस मामले में password) को bytes की sequence (बस एक string) में convert करना जो बेतरतीब दिखती है।
+
+जब भी आप बिल्कुल वही content (बिल्कुल वही password) पास करते हैं, तो आपको बिल्कुल वही बेतरतीब string मिलती है।
+
+लेकिन आप उस बेतरतीब string से वापस password में convert नहीं कर सकते।
+
+##### Password hashing का उपयोग क्यों करें { #why-use-password-hashing }
+
+अगर आपका database चोरी हो जाता है, तो चोर के पास आपके users के plaintext passwords नहीं होंगे, केवल hashes होंगे।
+
+इसलिए, चोर उन same passwords को किसी दूसरे system में उपयोग करने की कोशिश नहीं कर पाएगा (क्योंकि कई users हर जगह वही password उपयोग करते हैं, यह खतरनाक होगा)।
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[82:85] *}
+
+#### `**user_dict` के बारे में { #about-user-dict }
+
+`UserInDB(**user_dict)` का मतलब है:
+
+*`user_dict` की keys और values को सीधे key-value arguments के रूप में पास करें, इसके बराबर:*
+
+```Python
+UserInDB(
+    username = user_dict["username"],
+    email = user_dict["email"],
+    full_name = user_dict["full_name"],
+    disabled = user_dict["disabled"],
+    hashed_password = user_dict["hashed_password"],
+)
+```
+
+/// note | नोट
+
+`**user_dict` की अधिक पूरी explanation के लिए [**Extra Models** के documentation](../extra-models.md#about-user-in-model-dump) में वापस देखें।
+
+///
+
+## token लौटाएँ { #return-the-token }
+
+`token` endpoint का response एक JSON object होना चाहिए।
+
+इसमें `token_type` होना चाहिए। हमारे मामले में, क्योंकि हम "Bearer" tokens का उपयोग कर रहे हैं, token type "`bearer`" होना चाहिए।
+
+और इसमें `access_token` होना चाहिए, जिसमें हमारे access token वाली एक string हो।
+
+इस सरल उदाहरण के लिए, हम बस पूरी तरह insecure रहेंगे और token के रूप में वही `username` लौटाएँगे।
+
+/// tip | टिप
+
+अगले अध्याय में, आप password hashing और <abbr title="JSON Web Tokens - JSON वेब टोकन">JWT</abbr> tokens के साथ एक वास्तविक secure implementation देखेंगे।
+
+लेकिन अभी के लिए, आइए उन specific details पर ध्यान दें जिनकी हमें आवश्यकता है।
+
+///
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[87] *}
+
+/// tip | टिप
+
+Spec के अनुसार, आपको `access_token` और `token_type` के साथ एक JSON लौटाना चाहिए, बिल्कुल इस उदाहरण की तरह।
+
+यह कुछ ऐसा है जो आपको अपने code में स्वयं करना होगा, और सुनिश्चित करना होगा कि आप उन JSON keys का उपयोग करें।
+
+Specifications के compliant होने के लिए, यह लगभग एकमात्र चीज है जिसे आपको सही तरीके से खुद करना याद रखना होगा।
+
+बाकी सब **FastAPI** आपके लिए संभालता है।
+
+///
+
+## dependencies अपडेट करें { #update-the-dependencies }
+
+अब हम अपनी dependencies अपडेट करने वाले हैं।
+
+हम `current_user` को *केवल* तब प्राप्त करना चाहते हैं जब यह user active हो।
+
+इसलिए, हम एक अतिरिक्त dependency `get_current_active_user` बनाते हैं जो बदले में `get_current_user` को dependency के रूप में उपयोग करती है।
+
+ये दोनों dependencies बस एक HTTP error लौटाएँगी यदि user मौजूद नहीं है, या inactive है।
+
+इसलिए, हमारे endpoint में, हमें user केवल तभी मिलेगा जब user मौजूद हो, सही तरीके से authenticated हो, और active हो:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[58:66,69:74,94] *}
+
+/// note | नोट
+
+Value `Bearer` के साथ अतिरिक्त header `WWW-Authenticate`, जिसे हम यहाँ लौटा रहे हैं, spec का भी हिस्सा है।
+
+किसी भी HTTP (error) status code 401 "UNAUTHORIZED" को `WWW-Authenticate` header भी लौटाना चाहिए।
+
+Bearer tokens (हमारे मामले) में, उस header की value `Bearer` होनी चाहिए।
+
+आप वास्तव में उस अतिरिक्त header को छोड़ सकते हैं और फिर भी यह काम करेगा।
+
+लेकिन specifications के compliant होने के लिए इसे यहाँ प्रदान किया गया है।
+
+साथ ही, ऐसे tools हो सकते हैं जो इसकी अपेक्षा करते हैं और इसका उपयोग करते हैं (अभी या भविष्य में) और यह आपके या आपके users के लिए उपयोगी हो सकता है, अभी या भविष्य में।
+
+यही standards का लाभ है...
+
+///
+
+## इसे काम करते देखें { #see-it-in-action }
+
+Interactive docs खोलें: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)।
+
+### Authenticate करें { #authenticate }
+
+"Authorize" button पर click करें।
+
+Credentials का उपयोग करें:
+
+User: `johndoe`
+
+Password: `secret`
+
+<img src="/img/tutorial/security/image04.png">
+
+System में authenticate होने के बाद, आप इसे ऐसे देखेंगे:
+
+<img src="/img/tutorial/security/image05.png">
+
+### अपना user data प्राप्त करें { #get-your-own-user-data }
+
+अब path `/users/me` के साथ operation `GET` का उपयोग करें।
+
+आपको अपने user का data मिलेगा, जैसे:
+
+```JSON
+{
+  "username": "johndoe",
+  "email": "[email protected]",
+  "full_name": "John Doe",
+  "disabled": false,
+  "hashed_password": "fakehashedsecret"
+}
+```
+
+<img src="/img/tutorial/security/image06.png">
+
+यदि आप lock icon पर click करके logout करते हैं, और फिर वही operation दोबारा आज़माते हैं, तो आपको HTTP 401 error मिलेगा:
+
+```JSON
+{
+  "detail": "Not authenticated"
+}
+```
+
+### Inactive user { #inactive-user }
+
+अब एक inactive user के साथ प्रयास करें, इनके साथ authenticate करें:
+
+User: `alice`
+
+Password: `secret2`
+
+और path `/users/me` के साथ operation `GET` का उपयोग करने का प्रयास करें।
+
+आपको "Inactive user" error मिलेगा, जैसे:
+
+```JSON
+{
+  "detail": "Inactive user"
+}
+```
+
+## Recap { #recap }
+
+अब आपके पास अपनी API के लिए `username` और `password` पर आधारित एक पूरा security system implement करने के tools हैं।
+
+इन tools का उपयोग करके, आप security system को किसी भी database और किसी भी user या data model के साथ compatible बना सकते हैं।
+
+एकमात्र detail जो missing है वह यह है कि यह अभी वास्तव में "secure" नहीं है।
+
+अगले अध्याय में आप देखेंगे कि secure password hashing library और <abbr title="JSON Web Tokens - JSON वेब टोकन">JWT</abbr> tokens का उपयोग कैसे करें।

docs/hi/docs/tutorial/server-sent-events.md

@@ -0,0 +1,120 @@
+# Server-Sent Events (SSE) { #server-sent-events-sse }
+
+आप **Server-Sent Events** (SSE) का उपयोग करके client को data stream कर सकते हैं।
+
+यह [Stream JSON Lines](stream-json-lines.md) जैसा है, लेकिन `text/event-stream` format का उपयोग करता है, जिसे browsers [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) के साथ natively support करते हैं।
+
+/// note | नोट
+
+FastAPI 0.135.0 में जोड़ा गया।
+
+///
+
+## Server-Sent Events क्या हैं? { #what-are-server-sent-events }
+
+SSE, HTTP के माध्यम से server से client तक data stream करने के लिए एक standard है।
+
+हर event एक छोटा text block होता है जिसमें `data`, `event`, `id`, और `retry` जैसे "fields" होते हैं, जिन्हें खाली lines से अलग किया जाता है।
+
+यह ऐसा दिखता है:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE का उपयोग आमतौर पर AI chat streaming, live notifications, logs और observability, और अन्य मामलों में किया जाता है जहाँ server client को updates push करता है।
+
+/// tip | सुझाव
+
+अगर आप binary data stream करना चाहते हैं, जैसे video या audio, तो advanced guide देखें: [Data Stream करें](../advanced/stream-data.md).
+
+///
+
+## FastAPI के साथ SSE Stream करें { #stream-sse-with-fastapi }
+
+FastAPI के साथ SSE stream करने के लिए, अपनी *path operation function* में `yield` का उपयोग करें और `response_class=EventSourceResponse` set करें।
+
+`EventSourceResponse` को `fastapi.sse` से import करें:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+हर yielded item को JSON के रूप में encode किया जाता है और SSE event के `data:` field में भेजा जाता है।
+
+अगर आप return type को `AsyncIterable[Item]` के रूप में declare करते हैं, तो FastAPI इसका उपयोग Pydantic के साथ data को **validate**, **document**, और **serialize** करने के लिए करेगा।
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | सुझाव
+
+क्योंकि Pydantic इसे **Rust** side में serialize करेगा, आपको return type declare न करने की तुलना में कहीं बेहतर **performance** मिलेगी।
+
+///
+
+### Non-async *path operation functions* { #non-async-path-operation-functions }
+
+आप नियमित `def` functions (बिना `async`) का भी उपयोग कर सकते हैं, और उसी तरह `yield` का उपयोग कर सकते हैं।
+
+FastAPI सुनिश्चित करेगा कि यह सही तरीके से run हो ताकि यह event loop को block न करे।
+
+क्योंकि इस मामले में function async नहीं है, सही return type `Iterable[Item]` होगा:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### कोई Return Type नहीं { #no-return-type }
+
+आप return type को छोड़ भी सकते हैं। FastAPI data को convert करने और भेजने के लिए [`jsonable_encoder`](./encoder.md) का उपयोग करेगा।
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+अगर आपको `event`, `id`, `retry`, या `comment` जैसे SSE fields set करने की ज़रूरत है, तो आप plain data के बजाय `ServerSentEvent` objects yield कर सकते हैं।
+
+`ServerSentEvent` को `fastapi.sse` से import करें:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+`data` field हमेशा JSON के रूप में encode किया जाता है। आप कोई भी value pass कर सकते हैं जिसे JSON के रूप में serialize किया जा सकता हो, जिसमें Pydantic models भी शामिल हैं।
+
+## Raw Data { #raw-data }
+
+अगर आपको JSON encoding के **बिना** data भेजना है, तो `data` के बजाय `raw_data` का उपयोग करें।
+
+यह pre-formatted text, log lines, या `[DONE]` जैसे विशेष <dfn title="किसी विशेष condition या state को इंगित करने के लिए उपयोग किया गया value">"sentinel"</dfn> values भेजने के लिए उपयोगी है।
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | नोट
+
+`data` और `raw_data` mutually exclusive हैं। आप हर `ServerSentEvent` पर उनमें से केवल एक ही set कर सकते हैं।
+
+///
+
+## `Last-Event-ID` के साथ फिर से शुरू करना { #resuming-with-last-event-id }
+
+जब कोई browser connection drop होने के बाद reconnect करता है, तो वह अंतिम प्राप्त `id` को `Last-Event-ID` header में भेजता है।
+
+आप इसे header parameter के रूप में read कर सकते हैं और stream को वहाँ से resume करने के लिए उपयोग कर सकते हैं जहाँ client ने छोड़ा था:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## POST के साथ SSE { #sse-with-post }
+
+SSE **किसी भी HTTP method** के साथ काम करता है, केवल `GET` के साथ नहीं।
+
+यह [MCP](https://modelcontextprotocol.io) जैसे protocols के लिए उपयोगी है, जो `POST` पर SSE stream करते हैं:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## तकनीकी विवरण { #technical-details }
+
+FastAPI कुछ SSE best practices को out of the box implement करता है।
+
+* जब कोई message नहीं आया हो, तो हर 15 सेकंड में **"keep alive" `ping` comment** भेजें, ताकि कुछ proxies connection को close न कर दें, जैसा कि [HTML specification: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes) में सुझाया गया है।
+* stream की **caching रोकने** के लिए `Cache-Control: no-cache` header set करें।
+* Nginx जैसे कुछ proxies में **buffering रोकने** के लिए एक special header `X-Accel-Buffering: no` set करें।
+
+आपको इसके लिए कुछ भी करने की ज़रूरत नहीं है, यह out of the box काम करता है। 🤓

docs/hi/docs/tutorial/sql-databases.md

@@ -0,0 +1,357 @@
+# SQL (Relational) डेटाबेस { #sql-relational-databases }
+
+**FastAPI** के लिए SQL (relational) डेटाबेस इस्तेमाल करना required नहीं है। लेकिन आप **कोई भी डेटाबेस** इस्तेमाल कर सकते हैं जो आप चाहें।
+
+यहाँ हम [SQLModel](https://sqlmodel.tiangolo.com/) का उपयोग करके एक उदाहरण देखेंगे।
+
+**SQLModel**, [SQLAlchemy](https://www.sqlalchemy.org/) और Pydantic के ऊपर बना है। इसे **FastAPI** के उसी लेखक ने बनाया है ताकि यह उन FastAPI applications के लिए perfect match हो जिन्हें **SQL databases** इस्तेमाल करने की जरूरत होती है।
+
+/// tip | टिप
+
+आप अपनी पसंद की कोई भी दूसरी SQL या NoSQL डेटाबेस लाइब्रेरी इस्तेमाल कर सकते हैं (कुछ मामलों में इन्हें <abbr title="Object Relational Mapper - ऑब्जेक्ट रिलेशनल मैपर: एक लाइब्रेरी के लिए एक fancy शब्द जिसमें कुछ classes SQL tables को represent करती हैं और instances उन tables में rows को represent करते हैं">"ORMs"</abbr> कहा जाता है), FastAPI आपको कुछ भी इस्तेमाल करने के लिए मजबूर नहीं करता। 😎
+
+///
+
+क्योंकि SQLModel, SQLAlchemy पर आधारित है, आप SQLAlchemy द्वारा **supported कोई भी डेटाबेस** आसानी से इस्तेमाल कर सकते हैं (जिससे वे SQLModel द्वारा भी supported हो जाते हैं), जैसे:
+
+* PostgreSQL
+* MySQL
+* SQLite
+* Oracle
+* Microsoft SQL Server, आदि।
+
+इस उदाहरण में, हम **SQLite** इस्तेमाल करेंगे, क्योंकि यह एक single file का उपयोग करता है और Python में इसके लिए integrated support है। इसलिए, आप इस उदाहरण को copy कर सकते हैं और जैसा है वैसा ही run कर सकते हैं।
+
+बाद में, अपनी production application के लिए, आप **PostgreSQL** जैसा database server इस्तेमाल करना चाह सकते हैं।
+
+/// tip | टिप
+
+**FastAPI** और **PostgreSQL** के साथ एक official project generator है जिसमें frontend और अधिक tools शामिल हैं: [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
+
+///
+
+यह एक बहुत ही सरल और छोटा tutorial है, अगर आप सामान्य रूप से databases, SQL, या अधिक advanced features के बारे में सीखना चाहते हैं, तो [SQLModel docs](https://sqlmodel.tiangolo.com/) पर जाएँ।
+
+## `SQLModel` install करें { #install-sqlmodel }
+
+सबसे पहले, सुनिश्चित करें कि आप अपना [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर `sqlmodel` install करें:
+
+<div class="termy">
+
+```console
+$ pip install sqlmodel
+---> 100%
+```
+
+</div>
+
+## Single Model के साथ App बनाएँ { #create-the-app-with-a-single-model }
+
+हम पहले एक single **SQLModel** model के साथ app का सबसे सरल पहला version बनाएँगे।
+
+बाद में हम नीचे **multiple models** के साथ security और versatility बढ़ाते हुए इसे बेहतर बनाएँगे। 🤓
+
+### Models बनाएँ { #create-models }
+
+`SQLModel` import करें और एक डेटाबेस model बनाएँ:
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[1:11] hl[7:11] *}
+
+`Hero` class एक Pydantic model से बहुत मिलती-जुलती है (वास्तव में, अंदर से, यह सच में *एक Pydantic model ही है*)।
+
+कुछ अंतर हैं:
+
+* `table=True` SQLModel को बताता है कि यह एक *table model* है, इसे SQL डेटाबेस में एक **table** को represent करना चाहिए, यह सिर्फ एक *data model* नहीं है (जैसा कि कोई भी दूसरी regular Pydantic class होती)।
+
+* `Field(primary_key=True)` SQLModel को बताता है कि `id` SQL डेटाबेस में **primary key** है (आप SQL primary keys के बारे में SQLModel docs में अधिक जान सकते हैं)।
+
+    **ध्यान दें:** हम primary key field के लिए `int | None` का उपयोग करते हैं ताकि Python code में हम *बिना `id` के object बना सकें* (`id=None`), यह मानते हुए कि डेटाबेस *save करते समय इसे generate करेगा*। SQLModel समझता है कि डेटाबेस `id` provide करेगा और डेटाबेस schema में *column को non-null `INTEGER` के रूप में define करता है*। विवरण के लिए [primary keys पर SQLModel docs](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) देखें।
+
+* `Field(index=True)` SQLModel को बताता है कि उसे इस column के लिए एक **SQL index** बनाना चाहिए, जिससे इस column द्वारा filtered data पढ़ते समय डेटाबेस में तेज़ lookups हो सकें।
+
+    SQLModel जान जाएगा कि `str` के रूप में declared कोई चीज़ `TEXT` type का SQL column होगी (या डेटाबेस के आधार पर `VARCHAR`)।
+
+### Engine बनाएँ { #create-an-engine }
+
+SQLModel `engine` (अंदर से यह वास्तव में SQLAlchemy `engine` है) वह है जो डेटाबेस से **connections को hold** करता है।
+
+आपके सभी code के लिए उसी डेटाबेस से connect करने हेतु **एक single `engine` object** होगा।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *}
+
+`check_same_thread=False` का उपयोग FastAPI को अलग-अलग threads में वही SQLite डेटाबेस इस्तेमाल करने देता है। यह necessary है क्योंकि **एक single request** **एक से अधिक thread** का उपयोग कर सकती है (उदाहरण के लिए dependencies में)।
+
+चिंता न करें, code जिस तरह structured है, उससे हम सुनिश्चित करेंगे कि बाद में हम **प्रति request एक single SQLModel *session*** इस्तेमाल करें, वास्तव में `check_same_thread` यही हासिल करने की कोशिश कर रहा है।
+
+### Tables बनाएँ { #create-the-tables }
+
+फिर हम एक function जोड़ते हैं जो सभी *table models* के लिए **tables बनाने** हेतु `SQLModel.metadata.create_all(engine)` का उपयोग करता है।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *}
+
+### Session Dependency बनाएँ { #create-a-session-dependency }
+
+**`Session`** वह है जो **objects को memory में store** करता है और data में required किसी भी बदलाव का track रखता है, फिर यह डेटाबेस से communicate करने के लिए **`engine` का उपयोग करता है**।
+
+हम `yield` के साथ एक FastAPI **dependency** बनाएँगे जो हर request के लिए एक नया `Session` provide करेगी। यही सुनिश्चित करता है कि हम प्रति request एक single session इस्तेमाल करें। 🤓
+
+फिर हम इस dependency का उपयोग करने वाले बाकी code को आसान बनाने के लिए एक `Annotated` dependency `SessionDep` बनाते हैं।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[25:30]  hl[25:27,30] *}
+
+### Startup पर Database Tables बनाएँ { #create-database-tables-on-startup }
+
+हम application शुरू होने पर database tables बनाएँगे।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[32:37] hl[35:37] *}
+
+यहाँ हम application startup event पर tables बनाते हैं।
+
+production के लिए आप शायद एक migration script इस्तेमाल करेंगे जो आपका app शुरू करने से पहले run होती है। 🤓
+
+/// tip | टिप
+
+SQLModel में Alembic को wrap करने वाली migration utilities होंगी, लेकिन अभी के लिए, आप सीधे [Alembic](https://alembic.sqlalchemy.org/en/latest/) इस्तेमाल कर सकते हैं।
+
+///
+
+### Hero बनाएँ { #create-a-hero }
+
+क्योंकि हर SQLModel model एक Pydantic model भी है, आप इसे उसी **type annotations** में इस्तेमाल कर सकते हैं जिनमें आप Pydantic models इस्तेमाल करते।
+
+उदाहरण के लिए, अगर आप `Hero` type का parameter declare करते हैं, तो यह **JSON body** से read किया जाएगा।
+
+उसी तरह, आप इसे function के **return type** के रूप में declare कर सकते हैं, और फिर data का shape automatic API docs UI में दिखाई देगा।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[40:45] hl[40:45] *}
+
+यहाँ हम `SessionDep` dependency (एक `Session`) का उपयोग करके नए `Hero` को `Session` instance में add करते हैं, changes को डेटाबेस में commit करते हैं, `hero` में data refresh करते हैं, और फिर उसे return करते हैं।
+
+### Heroes पढ़ें { #read-heroes }
+
+हम `select()` का उपयोग करके डेटाबेस से `Hero`s **read** कर सकते हैं। results को paginate करने के लिए हम `limit` और `offset` include कर सकते हैं।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[48:55] hl[51:52,54] *}
+
+### एक Hero पढ़ें { #read-one-hero }
+
+हम एक single `Hero` **read** कर सकते हैं।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[58:63] hl[60] *}
+
+### Hero Delete करें { #delete-a-hero }
+
+हम एक `Hero` को **delete** भी कर सकते हैं।
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[66:73] hl[71] *}
+
+### App Run करें { #run-the-app }
+
+आप app run कर सकते हैं:
+
+<div class="termy">
+
+```console
+$ fastapi dev
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+फिर `/docs` UI पर जाएँ, आप देखेंगे कि **FastAPI** API को **document** करने के लिए इन **models** का उपयोग कर रहा है, और यह data को **serialize** और **validate** करने के लिए भी इनका उपयोग करेगा।
+
+<div class="screenshot">
+<img src="/img/tutorial/sql-databases/image01.png">
+</div>
+
+## Multiple Models के साथ App Update करें { #update-the-app-with-multiple-models }
+
+अब आइए **security** और **versatility** बढ़ाने के लिए इस app को थोड़ा **refactor** करें।
+
+अगर आप previous app देखें, तो UI में आप देख सकते हैं कि अभी तक यह client को बनने वाले `Hero` का `id` तय करने देता है। 😱
+
+हमें ऐसा नहीं होने देना चाहिए, वे DB में पहले से assigned किसी `id` को overwrite कर सकते हैं। `id` तय करना **backend** या **database** द्वारा किया जाना चाहिए, **client द्वारा नहीं**।
+
+इसके अलावा, हम hero के लिए `secret_name` बनाते हैं, लेकिन अब तक, हम इसे हर जगह return कर रहे हैं, यह बहुत **secret** नहीं है... 😅
+
+हम कुछ **extra models** जोड़कर इन चीज़ों को ठीक करेंगे। यहीं SQLModel चमकेगा। ✨
+
+### Multiple Models बनाएँ { #create-multiple-models }
+
+**SQLModel** में, कोई भी model class जिसमें `table=True` है, एक **table model** है।
+
+और कोई भी model class जिसमें `table=True` नहीं है, एक **data model** है, ये वास्तव में सिर्फ Pydantic models हैं (कुछ छोटे extra features के साथ)। 🤓
+
+SQLModel के साथ, हम सभी मामलों में सभी fields को **duplicate करने से बचने** के लिए **inheritance** का उपयोग कर सकते हैं।
+
+#### `HeroBase` - base class { #herobase-the-base-class }
+
+आइए एक `HeroBase` model से शुरू करें जिसमें सभी models द्वारा **shared fields** हों:
+
+* `name`
+* `age`
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:9] hl[7:9] *}
+
+#### `Hero` - *table model* { #hero-the-table-model }
+
+फिर आइए `Hero` बनाएँ, वास्तविक *table model*, जिसमें वे **extra fields** हों जो हमेशा दूसरे models में नहीं होते:
+
+* `id`
+* `secret_name`
+
+क्योंकि `Hero`, `HeroBase` से inherit करता है, इसमें `HeroBase` में declared **fields** भी हैं, इसलिए `Hero` के लिए सभी fields हैं:
+
+* `id`
+* `name`
+* `age`
+* `secret_name`
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:14] hl[12:14] *}
+
+#### `HeroPublic` - public *data model* { #heropublic-the-public-data-model }
+
+इसके बाद, हम एक `HeroPublic` model बनाते हैं, यही वह है जो API के clients को **return** किया जाएगा।
+
+इसमें `HeroBase` जैसे ही fields हैं, इसलिए इसमें `secret_name` शामिल नहीं होगा।
+
+आख़िरकार, हमारे heroes की identity protected है! 🥷
+
+यह `id: int` को फिर से declare भी करता है। ऐसा करके, हम API clients के साथ एक **contract** बना रहे हैं, ताकि वे हमेशा expect कर सकें कि `id` मौजूद होगा और `int` होगा (यह कभी `None` नहीं होगा)।
+
+/// tip | टिप
+
+return model से यह सुनिश्चित करवाना कि कोई value हमेशा available है और हमेशा `int` है (`None` नहीं), API clients के लिए बहुत उपयोगी है, वे इस certainty के साथ बहुत सरल code लिख सकते हैं।
+
+साथ ही, **automatically generated clients** में सरल interfaces होंगे, ताकि आपकी API से communicate करने वाले developers आपकी API के साथ काम करते समय बहुत बेहतर अनुभव पा सकें। 😎
+
+///
+
+`HeroPublic` में सभी fields `HeroBase` जैसे ही हैं, जिसमें `id` को `int` (`None` नहीं) के रूप में declared किया गया है:
+
+* `id`
+* `name`
+* `age`
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:18] hl[17:18] *}
+
+#### `HeroCreate` - hero बनाने के लिए *data model* { #herocreate-the-data-model-to-create-a-hero }
+
+अब हम एक `HeroCreate` model बनाते हैं, यही वह है जो clients से आने वाले data को **validate** करेगा।
+
+इसमें `HeroBase` जैसे ही fields हैं, और इसमें `secret_name` भी है।
+
+अब, जब clients **एक नया hero create** करेंगे, वे `secret_name` भेजेंगे, यह डेटाबेस में store होगा, लेकिन वे secret names API में clients को return नहीं किए जाएँगे।
+
+/// tip | टिप
+
+आप **passwords** को ऐसे handle करेंगे। उन्हें receive करें, लेकिन API में return न करें।
+
+आप passwords की values को store करने से पहले **hash** भी करेंगे, **उन्हें plain text में कभी store न करें**।
+
+///
+
+`HeroCreate` के fields हैं:
+
+* `name`
+* `age`
+* `secret_name`
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:22] hl[21:22] *}
+
+#### `HeroUpdate` - hero update करने के लिए *data model* { #heroupdate-the-data-model-to-update-a-hero }
+
+app के previous version में हमारे पास **hero update करने** का तरीका नहीं था, लेकिन अब **multiple models** के साथ, हम ऐसा कर सकते हैं। 🎉
+
+`HeroUpdate` *data model* थोड़ा special है, इसमें **वे सभी same fields** हैं जिनकी एक नया hero create करने के लिए जरूरत होगी, लेकिन सभी fields **optional** हैं (उन सभी की default value है)। इस तरह, जब आप hero update करते हैं, तो आप सिर्फ वे fields भेज सकते हैं जिन्हें आप update करना चाहते हैं।
+
+क्योंकि सभी **fields वास्तव में change होते हैं** (type में अब `None` शामिल है और अब उनकी default value `None` है), हमें उन्हें **re-declare** करना होगा।
+
+हमें वास्तव में `HeroBase` से inherit करने की जरूरत नहीं है क्योंकि हम सभी fields को re-declare कर रहे हैं। मैं consistency के लिए इसे inherit करता हुआ छोड़ूँगा, लेकिन यह necessary नहीं है। यह personal taste का मामला अधिक है। 🤷
+
+`HeroUpdate` के fields हैं:
+
+* `name`
+* `age`
+* `secret_name`
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:28] hl[25:28] *}
+
+### `HeroCreate` के साथ create करें और `HeroPublic` return करें { #create-with-herocreate-and-return-a-heropublic }
+
+अब जब हमारे पास **multiple models** हैं, हम app के उन parts को update कर सकते हैं जो उनका उपयोग करते हैं।
+
+हम request में एक `HeroCreate` *data model* receive करते हैं, और उससे, हम एक `Hero` *table model* बनाते हैं।
+
+इस नए *table model* `Hero` में client द्वारा भेजे गए fields होंगे, और इसमें डेटाबेस द्वारा generated एक `id` भी होगा।
+
+फिर हम उसी *table model* `Hero` को function से जैसा है वैसा ही return करते हैं। लेकिन क्योंकि हम `response_model` को `HeroPublic` *data model* के साथ declare करते हैं, **FastAPI** data को validate और serialize करने के लिए `HeroPublic` का उपयोग करेगा।
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[56:62] hl[56:58] *}
+
+/// tip | टिप
+
+अब हम **return type annotation** `-> HeroPublic` के बजाय `response_model=HeroPublic` इस्तेमाल करते हैं क्योंकि जो value हम return कर रहे हैं वह वास्तव में `HeroPublic` *नहीं* है।
+
+अगर हमने `-> HeroPublic` declare किया होता, तो आपका editor और linter complain करते (और सही करते) कि आप `HeroPublic` के बजाय `Hero` return कर रहे हैं।
+
+इसे `response_model` में declare करके हम **FastAPI** को अपना काम करने के लिए कह रहे हैं, बिना type annotations और आपके editor व अन्य tools से मिलने वाली help में interfere किए।
+
+///
+
+### `HeroPublic` के साथ Heroes पढ़ें { #read-heroes-with-heropublic }
+
+हम `Hero`s को **read** करने के लिए पहले जैसा ही कर सकते हैं, फिर से, हम यह सुनिश्चित करने के लिए `response_model=list[HeroPublic]` का उपयोग करते हैं कि data सही तरीके से validate और serialize हो।
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[65:72] hl[65] *}
+
+### `HeroPublic` के साथ एक Hero पढ़ें { #read-one-hero-with-heropublic }
+
+हम एक single hero **read** कर सकते हैं:
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[75:80] hl[77] *}
+
+### `HeroUpdate` के साथ Hero Update करें { #update-a-hero-with-heroupdate }
+
+हम **hero update** कर सकते हैं। इसके लिए हम HTTP `PATCH` operation इस्तेमाल करते हैं।
+
+और code में, हमें client द्वारा भेजे गए सभी data के साथ एक `dict` मिलता है, **सिर्फ client द्वारा भेजा गया data**, उन किसी भी values को exclude करते हुए जो सिर्फ default values होने के कारण वहाँ होतीं। ऐसा करने के लिए हम `exclude_unset=True` इस्तेमाल करते हैं। यही main trick है। 🪄
+
+फिर हम `hero_data` के data के साथ `hero_db` को update करने के लिए `hero_db.sqlmodel_update(hero_data)` इस्तेमाल करते हैं।
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[83:93] hl[83:84,88:89] *}
+
+### फिर से Hero Delete करें { #delete-a-hero-again }
+
+hero को **delete करना** लगभग पहले जैसा ही रहता है।
+
+हम इसमें सब कुछ refactor करने की इच्छा पूरी नहीं करेंगे। 😅
+
+{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[96:103] hl[101] *}
+
+### App फिर से Run करें { #run-the-app-again }
+
+आप app फिर से run कर सकते हैं:
+
+<div class="termy">
+
+```console
+$ fastapi dev
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+अगर आप `/docs` API UI पर जाते हैं, तो आप देखेंगे कि यह अब updated है, और hero create करते समय यह client से `id` receive करने की expect नहीं करेगा, आदि।
+
+<div class="screenshot">
+<img src="/img/tutorial/sql-databases/image02.png">
+</div>
+
+## Recap { #recap }
+
+आप SQL डेटाबेस के साथ interact करने और code को *data models* और *table models* के साथ सरल बनाने के लिए [**SQLModel**](https://sqlmodel.tiangolo.com/) का उपयोग कर सकते हैं।
+
+आप **SQLModel** docs में बहुत कुछ और सीख सकते हैं, वहाँ **FastAPI** के साथ SQLModel इस्तेमाल करने पर एक लंबा mini [tutorial](https://sqlmodel.tiangolo.com/tutorial/fastapi/) है। 🚀

docs/hi/docs/tutorial/static-files.md

@@ -0,0 +1,48 @@
+# Static Files { #static-files }
+
+आप `StaticFiles` का उपयोग करके किसी directory से static files को अपने-आप serve कर सकते हैं।
+
+/// tip | सुझाव
+
+अगर आपको frontend host करना है, तो इसके बजाय `app.frontend()` का उपयोग करें, इसके बारे में [Frontend](frontend.md) में पढ़ें।
+
+`app.frontend()` अंदरूनी तौर पर `StaticFiles` का उपयोग करता है, जिसमें frontends के लिए कई अतिरिक्त फायदे होते हैं, जैसे client-side routing को handle करना।
+
+///
+
+## `StaticFiles` का उपयोग करें { #use-staticfiles }
+
+* `StaticFiles` import करें।
+* किसी विशिष्ट path में `StaticFiles()` instance को "Mount" करें।
+
+{* ../../docs_src/static_files/tutorial001_py310.py hl[2,6] *}
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.staticfiles import StaticFiles` भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी, developer की, सुविधा के लिए वही `starlette.staticfiles` `fastapi.staticfiles` के रूप में प्रदान करता है। लेकिन यह वास्तव में सीधे Starlette से आता है।
+
+///
+
+### "Mounting" क्या है { #what-is-mounting }
+
+"Mounting" का मतलब है किसी विशिष्ट path में एक पूरी "independent" application जोड़ना, जो फिर सभी sub-paths को handle करने का काम करती है।
+
+यह `APIRouter` का उपयोग करने से अलग है, क्योंकि mounted application पूरी तरह independent होती है। आपकी main application की OpenAPI और docs में mounted application से कुछ भी शामिल नहीं होगा, आदि।
+
+आप इसके बारे में [Advanced User Guide](../advanced/index.md) में और पढ़ सकते हैं।
+
+## विवरण { #details }
+
+पहला `"/static"` उस sub-path को संदर्भित करता है जिस पर यह "sub-application" "mount" की जाएगी। इसलिए, `"/static"` से शुरू होने वाला कोई भी path इसके द्वारा handle किया जाएगा।
+
+`directory="static"` उस directory के नाम को संदर्भित करता है जिसमें आपकी static files होती हैं।
+
+`name="static"` इसे एक नाम देता है, जिसे **FastAPI** द्वारा internally उपयोग किया जा सकता है।
+
+ये सभी parameters "`static`" से अलग हो सकते हैं, इन्हें अपनी application की जरूरतों और विशिष्ट विवरणों के अनुसार adjust करें।
+
+## अधिक जानकारी { #more-info }
+
+अधिक विवरण और options के लिए [Static Files के बारे में Starlette की docs](https://www.starlette.dev/staticfiles/) देखें।

docs/hi/docs/tutorial/stream-json-lines.md

@@ -0,0 +1,111 @@
+# JSON Lines को Stream करें { #stream-json-lines }
+
+आपके पास data की एक sequence हो सकती है जिसे आप "**stream**" में भेजना चाहें, आप इसे **JSON Lines** के साथ कर सकते हैं।
+
+/// note | टिप्पणी
+
+FastAPI 0.134.0 में जोड़ा गया।
+
+///
+
+## Stream क्या है? { #what-is-a-stream }
+
+"**Streaming**" data का मतलब है कि आपका app items की पूरी sequence के तैयार होने का इंतज़ार किए बिना client को data items भेजना शुरू कर देगा।
+
+तो, यह पहला item भेजेगा, client उसे receive करके process करना शुरू कर देगा, और आप अभी भी अगला item produce कर रहे हो सकते हैं।
+
+```mermaid
+sequenceDiagram
+    participant App
+    participant Client
+
+    App->>App: Produce Item 1
+    App->>Client: Send Item 1
+    App->>App: Produce Item 2
+    Client->>Client: Process Item 1
+    App->>Client: Send Item 2
+    App->>App: Produce Item 3
+    Client->>Client: Process Item 2
+    App->>Client: Send Item 3
+    Client->>Client: Process Item 3
+    Note over App: Keeps producing...
+    Note over Client: Keeps consuming...
+```
+
+यह एक infinite stream भी हो सकती है, जहाँ आप लगातार data भेजते रहते हैं।
+
+## JSON Lines { #json-lines }
+
+इन मामलों में, "**JSON Lines**" भेजना आम है, जो एक ऐसा format है जहाँ आप हर line में एक JSON object भेजते हैं।
+
+एक response का content type `application/jsonl` होगा (`application/json` के बजाय) और body कुछ इस तरह होगी:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+यह JSON array (Python list के equivalent) से बहुत मिलता-जुलता है, लेकिन `[]` में wrap होने और items के बीच `,` होने के बजाय, इसमें **हर line में एक JSON object** होता है, वे एक new line character से अलग होते हैं।
+
+/// note | टिप्पणी
+
+महत्वपूर्ण बात यह है कि आपका app हर line को बारी-बारी से produce कर पाएगा, जबकि client पिछली lines को consume करता रहेगा।
+
+///
+
+/// note | तकनीकी विवरण
+
+क्योंकि हर JSON object एक new line से अलग होगा, उनके content में literal new line characters नहीं हो सकते, लेकिन उनमें escaped new lines (`\n`) हो सकती हैं, जो JSON standard का हिस्सा है।
+
+लेकिन आमतौर पर आपको इसके बारे में चिंता करने की ज़रूरत नहीं होगी, यह अपने आप हो जाता है, आगे पढ़ते रहें। 🤓
+
+///
+
+## उपयोग के मामले { #use-cases }
+
+आप इसका उपयोग **AI LLM** service से, **logs** या **telemetry** से, या अन्य प्रकार के data से data stream करने के लिए कर सकते हैं जिन्हें **JSON** items में structure किया जा सकता है।
+
+/// tip | सुझाव
+
+अगर आप binary data stream करना चाहते हैं, उदाहरण के लिए video या audio, तो advanced guide देखें: [Data Stream करें](../advanced/stream-data.md)।
+
+///
+
+## FastAPI के साथ JSON Lines Stream करें { #stream-json-lines-with-fastapi }
+
+FastAPI के साथ JSON Lines stream करने के लिए, आप अपनी *path operation function* में `return` का उपयोग करने के बजाय, हर item को बारी-बारी से produce करने के लिए `yield` का उपयोग कर सकते हैं।
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+अगर हर JSON item जिसे आप वापस भेजना चाहते हैं, type `Item` (एक Pydantic model) का है और यह एक async function है, तो आप return type को `AsyncIterable[Item]` के रूप में declare कर सकते हैं:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+अगर आप return type declare करते हैं, तो FastAPI इसका उपयोग data को **validate** करने, OpenAPI में इसे **document** करने, इसे **filter** करने, और Pydantic का उपयोग करके इसे **serialize** करने के लिए करेगा।
+
+/// tip | सुझाव
+
+क्योंकि Pydantic इसे **Rust** side में serialize करेगा, आपको return type declare न करने की तुलना में बहुत अधिक **performance** मिलेगी।
+
+///
+
+### Non-async *path operation functions* { #non-async-path-operation-functions }
+
+आप regular `def` functions (बिना `async` के) भी उपयोग कर सकते हैं, और उसी तरह `yield` का उपयोग कर सकते हैं।
+
+FastAPI यह सुनिश्चित करेगा कि यह सही तरीके से चले ताकि यह event loop को block न करे।
+
+क्योंकि इस मामले में function async नहीं है, सही return type `Iterable[Item]` होगा:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### कोई Return Type नहीं { #no-return-type }
+
+आप return type को omit भी कर सकते हैं। FastAPI फिर data को ऐसी चीज़ में convert करने के लिए [`jsonable_encoder`](./encoder.md) का उपयोग करेगा जिसे JSON में serialize किया जा सके और फिर उसे JSON Lines के रूप में भेजेगा।
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Server-Sent Events (SSE) { #server-sent-events-sse }
+
+FastAPI में Server-Sent Events (SSE) के लिए भी first-class support है, जो काफी समान हैं लेकिन कुछ extra details के साथ। आप इनके बारे में अगले chapter में जान सकते हैं: [Server-Sent Events (SSE)](server-sent-events.md)। 🤓

docs/hi/docs/tutorial/testing.md

@@ -0,0 +1,193 @@
+# Testing { #testing }
+
+[Starlette](https://www.starlette.dev/testclient/) की बदौलत, **FastAPI** applications की testing आसान और आनंददायक है।
+
+यह [HTTPX](https://www.python-httpx.org) पर आधारित है, जो बदले में Requests के आधार पर design किया गया है, इसलिए यह बहुत परिचित और intuitive है।
+
+इसके साथ, आप **FastAPI** के साथ सीधे [pytest](https://docs.pytest.org/) का उपयोग कर सकते हैं।
+
+## `TestClient` का उपयोग करना { #using-testclient }
+
+/// note | नोट
+
+`TestClient` का उपयोग करने के लिए, पहले [`httpx`](https://www.python-httpx.org) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install httpx
+```
+
+///
+
+`TestClient` import करें।
+
+अपनी **FastAPI** application को इसमें pass करके एक `TestClient` बनाएँ।
+
+ऐसी functions बनाएँ जिनका नाम `test_` से शुरू होता हो (यह एक standard `pytest` convention है)।
+
+`TestClient` object का उपयोग उसी तरह करें जैसे आप `httpx` के साथ करते हैं।
+
+जिन चीज़ों की आपको जाँच करनी है उनके लिए standard Python expressions के साथ सरल `assert` statements लिखें (फिर से, standard `pytest`)।
+
+{* ../../docs_src/app_testing/tutorial001_py310.py hl[2,12,15:18] *}
+
+/// tip | टिप
+
+ध्यान दें कि testing functions सामान्य `def` हैं, `async def` नहीं।
+
+और client को की जाने वाली calls भी सामान्य calls हैं, `await` का उपयोग नहीं करतीं।
+
+यह आपको बिना जटिलताओं के सीधे `pytest` का उपयोग करने देता है।
+
+///
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.testclient import TestClient` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, उसी `starlette.testclient` को `fastapi.testclient` के रूप में प्रदान करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+/// tip | टिप
+
+अगर आप अपनी FastAPI application को requests भेजने के अलावा अपने tests में `async` functions call करना चाहते हैं (जैसे asynchronous database functions), तो advanced tutorial में [Async Tests](../advanced/async-tests.md) देखें।
+
+///
+
+## Tests को अलग करना { #separating-tests }
+
+एक वास्तविक application में, आपके tests शायद किसी अलग file में होंगे।
+
+और आपकी **FastAPI** application भी कई files/modules आदि से मिलकर बनी हो सकती है।
+
+### **FastAPI** app file { #fastapi-app-file }
+
+मान लीजिए आपके पास [Bigger Applications](bigger-applications.md) में बताए गए अनुसार एक file structure है:
+
+```
+.
+├── app
+│   ├── __init__.py
+│   └── main.py
+```
+
+`main.py` file में आपकी **FastAPI** app है:
+
+
+{* ../../docs_src/app_testing/app_a_py310/main.py *}
+
+### Testing file { #testing-file }
+
+फिर आपके पास अपने tests के साथ एक file `test_main.py` हो सकती है। यह उसी Python package में हो सकती है (वही directory जिसमें `__init__.py` file है):
+
+``` hl_lines="5"
+.
+├── app
+│   ├── __init__.py
+│   ├── main.py
+│   └── test_main.py
+```
+
+क्योंकि यह file उसी package में है, आप `main` module (`main.py`) से object `app` को import करने के लिए relative imports का उपयोग कर सकते हैं:
+
+{* ../../docs_src/app_testing/app_a_py310/test_main.py hl[3] *}
+
+
+...और tests के लिए code पहले जैसा ही रख सकते हैं।
+
+## Testing: विस्तृत उदाहरण { #testing-extended-example }
+
+अब इस उदाहरण को आगे बढ़ाते हैं और अलग-अलग हिस्सों की testing कैसे करनी है यह देखने के लिए और विवरण जोड़ते हैं।
+
+### विस्तारित **FastAPI** app file { #extended-fastapi-app-file }
+
+आइए पहले जैसी ही file structure के साथ जारी रखें:
+
+```
+.
+├── app
+│   ├── __init__.py
+│   ├── main.py
+│   └── test_main.py
+```
+
+मान लीजिए अब आपकी **FastAPI** app वाली file `main.py` में कुछ अन्य **path operations** हैं।
+
+इसमें एक `GET` operation है जो error return कर सकता है।
+
+इसमें एक `POST` operation है जो कई errors return कर सकता है।
+
+दोनों *path operations* को `X-Token` header required है।
+
+{* ../../docs_src/app_testing/app_b_an_py310/main.py *}
+
+### विस्तारित testing file { #extended-testing-file }
+
+फिर आप विस्तारित tests के साथ `test_main.py` को update कर सकते हैं:
+
+{* ../../docs_src/app_testing/app_b_an_py310/test_main.py *}
+
+
+जब भी आपको client से request में जानकारी pass करवानी हो और आपको पता न हो कि कैसे, तो आप खोज (Google) सकते हैं कि इसे `httpx` में कैसे करें, या यहाँ तक कि `requests` के साथ कैसे करें, क्योंकि HTTPX का design Requests के design पर आधारित है।
+
+फिर आप अपने tests में वही करते हैं।
+
+उदाहरण के लिए:
+
+* *path* या *query* parameter pass करने के लिए, इसे URL में ही जोड़ें।
+* JSON body pass करने के लिए, `json` parameter में एक Python object (जैसे `dict`) pass करें।
+* अगर आपको JSON के बजाय *Form Data* भेजना है, तो इसके बजाय `data` parameter का उपयोग करें।
+* *headers* pass करने के लिए, `headers` parameter में एक `dict` का उपयोग करें।
+* *cookies* के लिए, `cookies` parameter में एक `dict`।
+
+backend को data कैसे pass करें (`httpx` या `TestClient` का उपयोग करके) इसके बारे में अधिक जानकारी के लिए [HTTPX documentation](https://www.python-httpx.org) देखें।
+
+/// note | नोट
+
+ध्यान दें कि `TestClient` ऐसा data receive करता है जिसे JSON में convert किया जा सकता है, Pydantic models नहीं।
+
+अगर आपके test में एक Pydantic model है और आप testing के दौरान उसका data application को भेजना चाहते हैं, तो आप [JSON Compatible Encoder](encoder.md) में बताए गए `jsonable_encoder` का उपयोग कर सकते हैं।
+
+///
+
+## इसे चलाएँ { #run-it }
+
+उसके बाद, आपको बस `pytest` install करना है।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+<div class="termy">
+
+```console
+$ pip install pytest
+
+---> 100%
+```
+
+</div>
+
+यह files और tests को automatically detect करेगा, उन्हें execute करेगा, और results आपको वापस report करेगा।
+
+Tests चलाएँ:
+
+<div class="termy">
+
+```console
+$ pytest
+
+================ test session starts ================
+platform linux -- Python 3.6.9, pytest-5.3.5, py-1.8.1, pluggy-0.13.1
+rootdir: /home/user/code/superawesome-cli/app
+plugins: forked-1.1.3, xdist-1.31.0, cov-2.8.1
+collected 6 items
+
+---> 100%
+
+test_main.py <span style="color: green; white-space: pre;">......                            [100%]</span>
+
+<span style="color: green;">================= 1 passed in 0.03s =================</span>
+```
+
+</div>