library/docs-fastapi
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Sync fastapi docs from 50113da1 on 2026-09-11

Browse Source
This commit is contained in:
The Librarian
2026-09-11 04:00:08 +00:00
parent 632909b5f6
commit 818066b271
739 changed files with 4974 additions and 17395 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/hi/docs/advanced/additional-responses.md
+2 -2
View File
@@ -243,5 +243,5 @@ new_dict = {**old_dict, "new key": "new value"}
Responses में आप ठीक-ठीक क्या शामिल कर सकते हैं, यह देखने के लिए आप OpenAPI specification में ये sections देख सकते हैं:
* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), इसमें `Response Object` शामिल है।
* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), आप इसमें से कुछ भी सीधे अपने `responses` parameter के अंदर प्रत्येक response में शामिल कर सकते हैं। जिसमें `description`, `headers`, `content` (इसी के अंदर आप अलग-अलग media types और JSON Schemas घोषित करते हैं), और `links` शामिल हैं।
* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object), इसमें `Response Object` शामिल है।
* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object), आप इसमें से कुछ भी सीधे अपने `responses` parameter के अंदर प्रत्येक response में शामिल कर सकते हैं। जिसमें `description`, `headers`, `content` (इसी के अंदर आप अलग-अलग media types और JSON Schemas घोषित करते हैं), और `links` शामिल हैं।
docs/hi/docs/advanced/async-tests.md
+1 -1
View File
@@ -45,7 +45,7 @@ file `test_main.py` में `main.py` के लिए tests होंगे,
<div class="termy">
```console
$ pytest
$ uv run pytest
---> 100%
```
docs/hi/docs/advanced/behind-a-proxy.md
+5 -5
View File
@@ -33,7 +33,7 @@ Proxy headers हैं:
<div class="termy">
```console
$ fastapi run --forwarded-allow-ips="*"
$ uv run fastapi run --forwarded-allow-ips="*"
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -170,7 +170,7 @@ Docs UI को OpenAPI schema में यह declare करने की भ
<div class="termy">
```console
$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -200,7 +200,7 @@ ASGI specification इस use case के लिए `root_path` define करत
<div class="termy">
```console
$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -253,7 +253,7 @@ Uvicorn अपेक्षा करेगा कि proxy Uvicorn को `http:
आप [Traefik](https://docs.traefik.io/) का उपयोग करके stripped path prefix के साथ experiment आसानी से locally चला सकते हैं।
[Traefik download करें](https://github.com/containous/traefik/releases), यह एक single binary है, आप compressed file extract कर सकते हैं और इसे सीधे terminal से चला सकते हैं।
[Traefik download करें](https://github.com/traefik/traefik/releases), यह एक single binary है, आप compressed file extract कर सकते हैं और इसे सीधे terminal से चला सकते हैं।
फिर `traefik.toml` नाम की file बनाएँ जिसमें यह हो:
@@ -321,7 +321,7 @@ INFO[0000] Configuration loaded from file: /home/user/awesomeapi/traefik.toml
<div class="termy">
```console
$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
docs/hi/docs/advanced/dataclasses.md
+2 -2
View File
@@ -6,7 +6,7 @@ FastAPI **Pydantic** के ऊपर बनाया गया है, और
{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
यह अभी भी **Pydantic** की वजह से support किया जाता है, क्योंकि इसमें [`dataclasses` के लिए internal support](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel) है।
यह अभी भी **Pydantic** की वजह से support किया जाता है, क्योंकि इसमें [`dataclasses` के लिए internal support](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/#usage-of-stdlib-dataclasses-with-basemodel) है।
इसलिए, ऊपर दिए गए code में भी, जो Pydantic का स्पष्ट रूप से उपयोग नहीं करता, FastAPI उन standard dataclasses को Pydantic की अपनी तरह की dataclasses में बदलने के लिए Pydantic का उपयोग कर रहा है।
@@ -88,7 +88,7 @@ dataclass अपने आप Pydantic dataclass में बदल जाए
आप `dataclasses` को अन्य Pydantic models के साथ भी जोड़ सकते हैं, उनसे inherit कर सकते हैं, उन्हें अपने models में शामिल कर सकते हैं, आदि।
अधिक जानने के लिए, [dataclasses के बारे में Pydantic docs](https://docs.pydantic.dev/latest/concepts/dataclasses/) देखें।
अधिक जानने के लिए, [dataclasses के बारे में Pydantic docs](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/) देखें।
## Version { #version }
docs/hi/docs/advanced/events.md
+6 -6
View File
@@ -1,4 +1,4 @@
# Lifespan Events { #lifespan-events }
# Lifespan event { #lifespan-events }
आप ऐसी logic (code) define कर सकते हैं जिसे application के **starts up** होने से पहले execute किया जाना चाहिए। इसका मतलब है कि यह code application के **requests receive करना शुरू करने से पहले**, **एक बार** execute होगा।
@@ -84,11 +84,11 @@ async with lifespan(app):
{* ../../docs_src/events/tutorial003_py310.py hl[22] *}
## Alternative Events (deprecated) { #alternative-events-deprecated }
## Alternative event (deprecated) { #alternative-events-deprecated }
/// warning | चेतावनी
*startup* और *shutdown* को handle करने का recommended तरीका ऊपर बताए गए अनुसार `FastAPI` app के `lifespan` parameter का use करना है। अगर आप `lifespan` parameter provide करते हैं, तो `startup` और `shutdown` event handlers अब call नहीं किए जाएंगे। यह पूरा `lifespan` होगा या पूरे events, दोनों नहीं।
*startup* और *shutdown* को handle करने का recommended तरीका ऊपर बताए गए अनुसार `FastAPI` app के `lifespan` parameter का use करना है। अगर आप `lifespan` parameter provide करते हैं, तो `startup` और `shutdown` event handlers अब call नहीं किए जाएंगे। यह पूरा `lifespan` होगा या पूरे event, दोनों नहीं।
आप शायद यह हिस्सा skip कर सकते हैं।
@@ -150,11 +150,11 @@ application के shutting down होने पर run होने वाल
जिज्ञासु nerds के लिए बस एक technical detail। 🤓
अंदर से, ASGI technical specification में, यह [Lifespan Protocol](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) का हिस्सा है, और यह `startup` और `shutdown` नाम के events define करता है।
अंदर से, ASGI technical specification में, यह [Lifespan Protocol](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) का हिस्सा है, और यह `startup` और `shutdown` नाम के event define करता है।
/// note | नोट
आप Starlette `lifespan` handlers के बारे में [Starlette की Lifespan docs](https://www.starlette.dev/lifespan/) में और पढ़ सकते हैं।
आप Starlette `lifespan` handlers के बारे में [Starlette की Lifespan docs](https://starlette.dev/lifespan/) में और पढ़ सकते हैं।
इसमें यह भी शामिल है कि lifespan state को कैसे handle किया जाए जिसे आपके code के अन्य areas में use किया जा सकता है।
@@ -162,4 +162,4 @@ application के shutting down होने पर run होने वाल
## Sub Applications { #sub-applications }
🚨 ध्यान रखें कि ये lifespan events (startup और shutdown) केवल main application के लिए execute होंगे, [Sub Applications - Mounts](sub-applications.md) के लिए नहीं।
🚨 ध्यान रखें कि ये lifespan event (startup और shutdown) केवल main application के लिए execute होंगे, [Sub Applications - Mounts](sub-applications.md) के लिए नहीं।
docs/hi/docs/advanced/generate-clients.md
+2 -2
View File
@@ -2,7 +2,7 @@
क्योंकि **FastAPI** **OpenAPI** specification पर आधारित है, इसकी APIs को एक standard format में वर्णित किया जा सकता है जिसे कई tools समझते हैं।
इससे up-to-date **documentation**, कई भाषाओं में client libraries (<abbr title="Software Development Kits - सॉफ़्टवेयर Development Kits">**SDKs**</abbr>), और **testing** या **automation workflows** जेनरेट करना आसान हो जाता है, जो आपके code के साथ sync में रहते हैं।
इससे up-to-date **documentation**, कई भाषाओं में client libraries (<abbr title="Software Development Kits - सॉफ़्टवेयर डेवलपमेंट किट्स">**SDKs**</abbr>), और **testing** या **automation workflows** जेनरेट करना आसान हो जाता है, जो आपके code के साथ sync में रहते हैं।
इस guide में, आप सीखेंगे कि अपने FastAPI backend के लिए **TypeScript SDK** कैसे जेनरेट करें।
@@ -12,7 +12,7 @@
**TypeScript clients** के लिए, [Hey API](https://heyapi.dev/) एक purpose-built solution है, जो TypeScript ecosystem के लिए optimized experience प्रदान करता है।
आप [OpenAPI.Tools](https://openapi.tools/#sdk) पर और SDK generators खोज सकते हैं।
आप [OpenAPI.Tools](https://openapi.tools/categories/sdk-generators) पर और SDK generators खोज सकते हैं।
/// tip | सुझाव
docs/hi/docs/advanced/middleware.md
+2 -2
View File
@@ -91,7 +91,7 @@ middleware standard और streaming दोनों responses को handle क
उदाहरण के लिए:
* [Uvicorn का `ProxyHeadersMiddleware`](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
* [Uvicorn का `ProxyHeadersMiddleware`](https://github.com/Kludex/uvicorn/blob/main/uvicorn/middleware/proxy_headers.py)
* [MessagePack](https://github.com/florimondmanca/msgpack-asgi)
अन्य उपलब्ध middleware देखने के लिए [Starlette के Middleware docs](https://www.starlette.dev/middleware/) और [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi) देखें।
अन्य उपलब्ध middleware देखने के लिए [Starlette के Middleware docs](https://starlette.dev/middleware/) और [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi) देखें।
docs/hi/docs/advanced/openapi-callbacks.md
+3 -3
View File
@@ -35,7 +35,7 @@ Callback जोड़ने से पहले, पहले देखते
/// tip | सुझाव
`callback_url` query parameter एक Pydantic [Url](https://docs.pydantic.dev/latest/api/networks/) type का उपयोग करता है।
`callback_url` query parameter एक Pydantic [Url](https://pydantic.dev/docs/validation/latest/api/pydantic/networks/) type का उपयोग करता है।
///
@@ -106,11 +106,11 @@ Callback *path operation* बनाने के लिए वही `APIRouter`
सामान्य *path operation* से 2 मुख्य अंतर हैं:
* इसमें कोई वास्तविक code होना required नहीं है, क्योंकि आपकी app इस code को कभी call नहीं करेगी। इसका उपयोग केवल *external API* को document करने के लिए किया जाता है। इसलिए, function में केवल `pass` हो सकता है।
* *path* में एक [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (नीचे और देखें) हो सकता है, जहाँ यह *आपकी API* को भेजी गई original request के parameters और parts के साथ variables का उपयोग कर सकता है।
* *path* में एक [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) (नीचे और देखें) हो सकता है, जहाँ यह *आपकी API* को भेजी गई original request के parameters और parts के साथ variables का उपयोग कर सकता है।
### Callback path expression { #the-callback-path-expression }
Callback *path* में एक [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) हो सकता है जो *आपकी API* को भेजी गई original request के parts शामिल कर सकता है।
Callback *path* में एक [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) हो सकता है जो *आपकी API* को भेजी गई original request के parts शामिल कर सकता है।
इस case में, यह `str` है:
docs/hi/docs/advanced/response-cookies.md
+1 -1
View File
@@ -48,4 +48,4 @@
///
सभी उपलब्ध parameters और options देखने के लिए, [Starlette में documentation](https://www.starlette.dev/responses/#set-cookie) देखें।
सभी उपलब्ध parameters और options देखने के लिए, [Starlette में documentation](https://starlette.dev/responses/#set-cookie) देखें।
docs/hi/docs/advanced/response-headers.md
+1 -1
View File
@@ -38,4 +38,4 @@
ध्यान रखें कि 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)](../tutorial/cors.md) में और पढ़ें), इसके लिए [Starlette के CORS docs](https://www.starlette.dev/middleware/#corsmiddleware) में documented parameter `expose_headers` का उपयोग करें।
लेकिन अगर आपके पास custom headers हैं जिन्हें आप चाहते हैं कि browser में कोई client देख सके, तो आपको उन्हें अपनी CORS configurations में जोड़ना होगा ([CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) में और पढ़ें), इसके लिए [Starlette के CORS docs](https://starlette.dev/middleware/#corsmiddleware) में documented parameter `expose_headers` का उपयोग करें।
docs/hi/docs/advanced/settings.md
+35 -11
View File
@@ -6,9 +6,13 @@
इसी कारण उन्हें आम तौर पर environment variables में दिया जाता है जिन्हें application पढ़ती है।
एक **environment variable** (जिसे **env var** भी कहा जाता है) एक value है जो Python code के बाहर, operating system में रहती है, और आपकी application और दूसरे programs द्वारा पढ़ी जा सकती है।
जब आप कोई command चलाते हैं, तो आप उसके लिए एक environment variable बना सकते हैं। आप नीचे platform-specific commands देखेंगे।
/// tip | सुझाव
Environment variables को समझने के लिए आप [Environment Variables](../environment-variables.md) पढ़ सकते हैं।
Environment variables कैसे काम करते हैं, इसकी विस्तृत व्याख्या के लिए [Environment Variables guide](https://tiangolo.com/guides/environment-variables/) पढ़ें।
///
@@ -20,27 +24,27 @@ Environment variables को समझने के लिए आप [Environmen
## Pydantic `Settings` { #pydantic-settings }
सौभाग्य से, Pydantic environment variables से आने वाली इन settings को handle करने के लिए एक बेहतरीन utility देता है: [Pydantic: Settings management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)।
सौभाग्य से, Pydantic environment variables से आने वाली इन settings को handle करने के लिए [Pydantic: Settings management](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) के साथ एक बेहतरीन utility देता है।
### `pydantic-settings` install करें { #install-pydantic-settings }
सबसे पहले, सुनिश्चित करें कि आप अपना [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर `pydantic-settings` package install करते हैं:
`pydantic-settings` package को अपने project में add करें:
<div class="termy">
```console
$ pip install pydantic-settings
$ uv add pydantic-settings
---> 100%
```
</div>
जब आप `all` extras को install करते हैं, तो यह भी शामिल आता है:
जब आप `all` extras को इनके साथ install करते हैं, तो यह भी शामिल आता है:
<div class="termy">
```console
$ pip install "fastapi[all]"
$ uv add "fastapi[all]"
---> 100%
```
@@ -76,19 +80,39 @@ Pydantic models की तरह ही, आप type annotations के सा
इसके बाद, आप configurations को environment variables के रूप में pass करते हुए server चलाएँगे, उदाहरण के लिए आप `ADMIN_EMAIL` और `APP_NAME` set कर सकते हैं:
//// tab | Linux, macOS, Windows Bash
<div class="termy">
```console
$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py
$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" uv run fastapi run main.py
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
////
//// tab | Windows PowerShell
<div class="termy">
```console
$ $Env:ADMIN_EMAIL = "deadpool@example.com"
$ $Env:APP_NAME = "ChimichangApp"
$ uv run fastapi run main.py
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
////
/// tip | सुझाव
एक ही command के लिए कई env vars set करने के लिए बस उन्हें space से अलग करें, और उन सभी को command से पहले रखें।
Bash में, एक ही command के लिए कई env vars set करने के लिए, उन्हें space से अलग करें और उन सभी को command से पहले रखें।
///
@@ -172,11 +196,11 @@ dot (`.`) से शुरू होने वाली file Unix-like systems,
///
Pydantic के पास external library का उपयोग करके इस प्रकार की files से पढ़ने के लिए support है। आप [Pydantic Settings: Dotenv (.env) support](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support) पर और पढ़ सकते हैं।
Pydantic के पास external library का उपयोग करके इस प्रकार की files से पढ़ने के लिए support है। आप [Pydantic Settings: Dotenv (.env) support](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support) पर और पढ़ सकते हैं।
/// tip | सुझाव
इसे काम करने के लिए, आपको `pip install python-dotenv` करना होगा।
इसे काम करने के लिए, `uv add python-dotenv` के साथ `python-dotenv` को अपने project में add करें।
///
@@ -197,7 +221,7 @@ APP_NAME="ChimichangApp"
/// tip | सुझाव
`model_config` attribute केवल Pydantic configuration के लिए उपयोग किया जाता है। आप [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/) पर और पढ़ सकते हैं।
`model_config` attribute केवल Pydantic configuration के लिए उपयोग किया जाता है। आप [Pydantic: Concepts: Configuration](https://pydantic.dev/docs/validation/latest/concepts/config/) पर और पढ़ सकते हैं।
///
docs/hi/docs/advanced/sub-applications.md
+1 -1
View File
@@ -35,7 +35,7 @@
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
docs/hi/docs/advanced/templates.md
+3 -3
View File
@@ -8,12 +8,12 @@
## Dependencies install करें { #install-dependencies }
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और `jinja2` install करें:
अपने project में `jinja2` जोड़ें:
<div class="termy">
```console
$ pip install jinja2
$ uv add jinja2
---> 100%
```
@@ -123,4 +123,4 @@ Item ID: 42
## अधिक विवरण { #more-details }
अधिक विवरण के लिए, जिसमें templates को test करना भी शामिल है, [templates पर Starlette के docs](https://www.starlette.dev/templates/) देखें।
अधिक विवरण के लिए, जिसमें templates को test करना भी शामिल है, [templates पर Starlette के docs](https://starlette.dev/templates/) देखें।
docs/hi/docs/advanced/testing-events.md
+2 -2
View File
@@ -5,8 +5,8 @@
{* ../../docs_src/app_testing/tutorial004_py310.py hl[9:15,18,27:28,30:32,41:43] *}
आप इसके बारे में अधिक विवरण ["आधिकारिक Starlette documentation site में tests में lifespan चलाना।"](https://www.starlette.dev/lifespan/#running-lifespan-in-tests) में पढ़ सकते हैं।
आप इसके बारे में अधिक विवरण ["आधिकारिक Starlette documentation site में tests में lifespan चलाना।"](https://starlette.dev/lifespan/#running-lifespan-in-tests) में पढ़ सकते हैं।
deprecated `startup` और `shutdown` event के लिए, आप `TestClient` का उपयोग इस प्रकार कर सकते हैं:
deprecated `startup` और `shutdown` events के लिए, आप `TestClient` का उपयोग इस प्रकार कर सकते हैं:
{* ../../docs_src/app_testing/tutorial003_py310.py hl[9:12,20:24] *}
docs/hi/docs/advanced/testing-websockets.md
+1 -1
View File
@@ -8,6 +8,6 @@
/// note | नोट
अधिक जानकारी के लिए, Starlette की documentation में [WebSockets की testing](https://www.starlette.dev/testclient/#testing-websocket-sessions) देखें।
अधिक जानकारी के लिए, Starlette की documentation में [WebSockets की testing](https://starlette.dev/testclient/#testing-websocket-sessions) देखें।
///
docs/hi/docs/advanced/using-request-directly.md
+2 -2
View File
@@ -15,7 +15,7 @@ Data लेना:
## `Request` object के बारे में विवरण { #details-about-the-request-object }
क्योंकि **FastAPI** असल में नीचे से **Starlette** है, जिसके ऊपर कई tools की एक layer है, इसलिए जब ज़रूरत हो, आप Starlette के [`Request`](https://www.starlette.dev/requests/) object को सीधे इस्तेमाल कर सकते हैं।
क्योंकि **FastAPI** असल में नीचे से **Starlette** है, जिसके ऊपर कई tools की एक layer है, इसलिए जब ज़रूरत हो, आप Starlette के [`Request`](https://starlette.dev/requests/) object को सीधे इस्तेमाल कर सकते हैं।
इसका मतलब यह भी होगा कि अगर आप `Request` object से सीधे data लेते हैं (उदाहरण के लिए, body पढ़ते हैं), तो FastAPI उसे validate, convert या document नहीं करेगा (OpenAPI के साथ, automatic API user interface के लिए)।
@@ -45,7 +45,7 @@ Data लेना:
## `Request` documentation { #request-documentation }
आप [`Request` object के बारे में official Starlette documentation site](https://www.starlette.dev/requests/) पर और विवरण पढ़ सकते हैं।
आप [`Request` object के बारे में official Starlette documentation site](https://starlette.dev/requests/) पर और विवरण पढ़ सकते हैं।
/// note | तकनीकी विवरण
docs/hi/docs/advanced/websockets.md
+6 -6
View File
@@ -4,12 +4,12 @@
## `websockets` install करें { #install-websockets }
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और `websockets` install करें (एक Python library जो "WebSocket" protocol का उपयोग आसान बनाती है):
अपने project में `websockets` (एक Python library जो "WebSocket" protocol का उपयोग आसान बनाती है) जोड़ें:
<div class="termy">
```console
$ pip install websockets
$ uv add websockets
---> 100%
```
@@ -69,7 +69,7 @@ production में आपके पास ऊपर दिए गए विक
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -126,7 +126,7 @@ WebSocket endpoints में आप `fastapi` से import कर सकते
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -182,5 +182,5 @@ Client #1596980209979 left the chat
विकल्पों के बारे में अधिक जानने के लिए, इनके लिए Starlette का documentation देखें:
* [`WebSocket` class](https://www.starlette.dev/websockets/)।
* [Class-based WebSocket handling](https://www.starlette.dev/endpoints/#websocketendpoint)।
* [`WebSocket` class](https://starlette.dev/websockets/)।
* [Class-based WebSocket handling](https://starlette.dev/endpoints/#websocketendpoint)।
docs/hi/docs/advanced/wsgi.md
+1 -1
View File
@@ -8,7 +8,7 @@
/// note | नोट
इसके लिए `a2wsgi` install करना required है, उदाहरण के लिए `pip install a2wsgi` के साथ।
इसके लिए अपने project में `a2wsgi` जोड़ना required है, उदाहरण के लिए `uv add a2wsgi` के साथ।
///
docs/hi/docs/alternatives.md
+6 -6
View File
@@ -125,7 +125,7 @@ Custom schema के बजाय API specifications के लिए एक ope
और standards-based user interface tools को integrate किया जाए:
* [Swagger UI](https://github.com/swagger-api/swagger-ui)
* [ReDoc](https://github.com/Rebilly/ReDoc)
* [ReDoc](https://github.com/Redocly/redoc)
इन दोनों को इसलिए चुना गया क्योंकि ये काफी popular और stable थे, लेकिन एक quick search करने पर, आप OpenAPI के लिए दर्जनों alternative user interfaces पा सकते हैं (जिन्हें आप **FastAPI** के साथ उपयोग कर सकते हैं)।
@@ -237,7 +237,7 @@ OpenAPI schema को automatically generate किया जाए, उसी c
///
### [NestJS](https://nestjs.com/) (और [Angular](https://angular.io/)) { #nestjs-and-angular }
### [NestJS](https://nestjs.com/) (और [Angular](https://angular.dev/)) { #nestjs-and-angular }
यह Python भी नहीं है, NestJS Angular से प्रेरित एक JavaScript (TypeScript) NodeJS framework है।
@@ -337,7 +337,7 @@ Hug उन पहले frameworks में से एक था जिसन
/// note | नोट
Hug को Timothy Crosley ने बनाया था, वही [`isort`](https://github.com/timothycrosley/isort) के creator हैं, जो Python files में imports को automatically sort करने के लिए एक बेहतरीन tool है।
Hug को Timothy Crosley ने बनाया था, वही [`isort`](https://github.com/PyCQA/isort) के creator हैं, जो Python files में imports को automatically sort करने के लिए एक बेहतरीन tool है।
///
@@ -401,7 +401,7 @@ APIStar को Tom Christie ने बनाया था। वही व्य
## **FastAPI** द्वारा उपयोग किया गया { #used-by-fastapi }
### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
### [Pydantic](https://pydantic.dev/docs/) { #pydantic }
Pydantic Python type hints के आधार पर data validation, serialization और documentation (JSON Schema का उपयोग करके) define करने के लिए एक library है।
@@ -417,7 +417,7 @@ Pydantic Python type hints के आधार पर data validation, serializa
///
### [Starlette](https://www.starlette.dev/) { #starlette }
### [Starlette](https://starlette.dev/) { #starlette }
Starlette एक lightweight <dfn title="asynchronous Python web applications बनाने के लिए नया standard">ASGI</dfn> framework/toolkit है, जो high-performance asyncio services बनाने के लिए ideal है।
@@ -462,7 +462,7 @@ Class `FastAPI` खुद सीधे class `Starlette` से inherit कर
///
### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
### [Uvicorn](https://uvicorn.dev) { #uvicorn }
Uvicorn एक lightning-fast ASGI server है, जो uvloop और httptools पर बना है।
docs/hi/docs/deployment/docker.md
+15 -19
View File
@@ -105,36 +105,32 @@ Container में सामान्यतः **single process** होता
### Package Requirements { #package-requirements }
आपकी application के लिए **package requirements** सामान्यतः किसी file में होंगे।
जब आप अपना project `uv` से manage करते हैं, तो इसकी direct dependencies `pyproject.toml` में declared होती हैं और exact resolved versions `uv.lock` में stored होते हैं।
यह मुख्य रूप से उस tool पर निर्भर करेगा जिसका उपयोग आप उन requirements को **install** करने के लिए करते हैं।
इसे करने का सबसे आम तरीका है `requirements.txt` file रखना, जिसमें package names और उनके versions हों, प्रति line एक।
आप versions की ranges set करने के लिए निश्चित रूप से वही ideas उपयोग करेंगे जो आपने [FastAPI versions के बारे में](versions.md) में पढ़े हैं।
उदाहरण के लिए, आपका `requirements.txt` ऐसा दिख सकता है:
```
fastapi[standard]>=0.113.0,<0.114.0
pydantic>=2.7.0,<3.0.0
```
और आप सामान्यतः उन package dependencies को `pip` से install करेंगे, उदाहरण के लिए:
आप अपनी application के लिए required packages इस तरह जोड़ सकते हैं:
<div class="termy">
```console
$ pip install -r requirements.txt
$ uv add "fastapi[standard]" pydantic
---> 100%
Successfully installed fastapi pydantic
```
</div>
/// note | नोट
Package dependencies define और install करने के लिए अन्य formats और tools भी हैं।
नीचे दिया गया Dockerfile container के अंदर `pip` उपयोग करता है। आप अपने uv project से locked dependencies को उसके expected `requirements.txt` format में export कर सकते हैं:
<div class="termy">
```console
$ uv export --format requirements-txt --no-dev --no-emit-project --output-file requirements.txt
```
</div>
Generated `requirements.txt` container build के लिए एक export है। Dependencies को `uv add` से manage करना जारी रखें और जब `uv.lock` change हो तो इसे regenerate करें।
///
@@ -372,7 +368,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
और आप [http://192.168.99.100/redoc](http://192.168.99.100/redoc) या [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (या equivalent, अपने Docker host का उपयोग करके) पर भी जा सकते हैं।
आप alternative automatic documentation देखेंगे ([ReDoc](https://github.com/Rebilly/ReDoc) द्वारा provided):
आप alternative automatic documentation देखेंगे ([ReDoc](https://github.com/Redocly/redoc) द्वारा provided):
![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
docs/hi/docs/deployment/fastapicloud.md
+1 -1
View File
@@ -5,7 +5,7 @@
<div class="termy">
```console
$ fastapi deploy
$ uv run fastapi deploy
Deploying to FastAPI Cloud...
docs/hi/docs/deployment/manually.md
+6 -6
View File
@@ -46,13 +46,13 @@ $ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid
आइए details में थोड़ा और गहराई से देखें।
FastAPI Python web frameworks और servers बनाने के लिए एक standard का उपयोग करता है जिसे <abbr title="Asynchronous Server Gateway Interface - asynchronous server gateway interface">ASGI</abbr> कहा जाता है। FastAPI एक ASGI web framework है।
FastAPI Python web frameworks और servers बनाने के लिए एक standard का उपयोग करता है जिसे <abbr title="Asynchronous Server Gateway Interface - asynchronous सर्वर गेटवे इंटरफेस">ASGI</abbr> कहा जाता है। FastAPI एक ASGI web framework है।
किसी remote server machine में **FastAPI** application (या कोई भी दूसरी ASGI application) चलाने के लिए आपको मुख्य रूप से एक ASGI server program चाहिए, जैसे **Uvicorn**; यही `fastapi` command में default रूप से आता है।
कई विकल्प हैं, जिनमें शामिल हैं:
* [Uvicorn](https://www.uvicorn.dev/): एक high performance ASGI server।
* [Uvicorn](https://uvicorn.dev): एक high performance ASGI server।
* [Hypercorn](https://hypercorn.readthedocs.io/): एक ASGI server जो अन्य features के साथ HTTP/2 और Trio के साथ compatible है।
* [Daphne](https://github.com/django/daphne): Django Channels के लिए बनाया गया ASGI server।
* [Granian](https://github.com/emmett-framework/granian): Python applications के लिए एक Rust HTTP server।
@@ -73,14 +73,14 @@ Remote machine का संदर्भ देते समय, इसे **ser
लेकिन आप एक ASGI server को मैन्युअली भी install कर सकते हैं।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर आप server application install कर सकते हैं।
Server application को अपने project में जोड़ें।
उदाहरण के लिए, Uvicorn install करने के लिए:
<div class="termy">
```console
$ pip install "uvicorn[standard]"
$ uv add "uvicorn[standard]"
---> 100%
```
@@ -95,7 +95,7 @@ $ pip install "uvicorn[standard]"
इसमें `uvloop` शामिल है, जो `asyncio` के लिए high-performance drop-in replacement है, और बड़ा concurrency performance boost देता है।
जब आप `pip install "fastapi[standard]"` जैसी किसी command से FastAPI install करते हैं, तो आपको `uvicorn[standard]` भी मिल जाता है।
जब आप `uv add "fastapi[standard]"` जैसी किसी चीज़ से FastAPI जोड़ते हैं, तो आपको `uvicorn[standard]` भी मिल जाता है।
///
@@ -106,7 +106,7 @@ $ pip install "uvicorn[standard]"
<div class="termy">
```console
$ uvicorn main:app --host 0.0.0.0 --port 80
$ uv run uvicorn main:app --host 0.0.0.0 --port 80
<span style="color: green;">INFO</span>: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
```
docs/hi/docs/deployment/server-workers.md
+1 -1
View File
@@ -86,7 +86,7 @@ $ <font color="#4E9A06">fastapi</font> run --workers 4 <u style="text-decoration
<div class="termy">
```console
$ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
$ uv run uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
<font color="#A6E22E">INFO</font>: Uvicorn running on <b>http://0.0.0.0:8080</b> (Press CTRL+C to quit)
<font color="#A6E22E">INFO</font>: Started parent process [<font color="#A1EFE4"><b>27365</b></font>]
<font color="#A6E22E">INFO</font>: Started server process [<font color="#A1EFE4">27368</font>]
docs/hi/docs/environment-variables.md
+5 -292
View File
@@ -1,298 +1,11 @@
# Environment Variables { #environment-variables }
/// tip | टिप
एक **environment variable** (जिसे **env var** भी कहा जाता है) एक value है जो आपके Python code के बाहर, ऑपरेटिंग सिस्टम में रहता है, और आपकी application और दूसरे programs द्वारा पढ़ा जा सकता है।
अगर आप पहले से जानते हैं कि "environment variables" क्या होते हैं और उनका उपयोग कैसे करना है, तो आप इसे छोड़ सकते हैं।
FastAPI applications आमतौर पर database URLs, email credentials, और secret keys जैसे configuration के लिए environment variables का उपयोग करते हैं।
///
आप [Settings और Environment Variables](advanced/settings.md) में application configuration के लिए उनका उपयोग करना सीखेंगे।
एक environment variable (जिसे "**env var**" भी कहा जाता है) एक variable है जो Python code के **बाहर**, **ऑपरेटिंग सिस्टम** में रहता है, और जिसे आपका Python code (या दूसरे programs भी) पढ़ सकते हैं।
## और जानें { #learn-more }
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) के बारे में, आपको इस जानकारी की ज़रूरत होगी।
एक विस्तृत, cross-platform explanation के लिए [Environment Variables guide](https://tiangolo.com/guides/environment-variables/) पढ़ें, जिसमें environment variables बनाना और पढ़ना, और `PATH` environment variable कैसे काम करता है, शामिल है।
docs/hi/docs/fastapi-cli.md
+10 -6
View File
@@ -2,7 +2,7 @@
**FastAPI <abbr title="command line interface - कमांड लाइन इंटरफ़ेस">CLI</abbr>** एक command line प्रोग्राम है जिसका उपयोग आप अपने FastAPI ऐप को serve करने, अपने FastAPI project को manage करने, और भी बहुत कुछ करने के लिए कर सकते हैं।
जब आप FastAPI install करते हैं (जैसे `pip install "fastapi[standard]"` के साथ), तो इसके साथ एक command line प्रोग्राम आता है जिसे आप terminal में चला सकते हैं।
जब आप अपने project में FastAPI add करते हैं (जैसे `uv add "fastapi[standard]"` के साथ), तो इसके साथ एक command line प्रोग्राम आता है जिसे आप terminal में चला सकते हैं।
development के लिए अपना FastAPI ऐप चलाने के लिए, आप `fastapi dev` command का उपयोग कर सकते हैं:
@@ -48,11 +48,11 @@ $ <font color="#4E9A06">fastapi</font> dev
/// tip | सुझाव
production के लिए आप `fastapi dev` की जगह `fastapi run` का उपयोग करेंगे। 🚀
production के लिए आप `fastapi run` का उपयोग करेंगे, `fastapi dev` की जगह। 🚀
///
आंतरिक रूप से, **FastAPI CLI** [Uvicorn](https://www.uvicorn.dev) का उपयोग करता है, जो एक high-performance, production-ready, ASGI server है। 😎
आंतरिक रूप से, **FastAPI CLI** [Uvicorn](https://uvicorn.dev) का उपयोग करता है, जो एक high-performance, production-ready, ASGI server है। 😎
`fastapi` CLI चलाने के लिए FastAPI ऐप को अपने-आप detect करने की कोशिश करेगा, यह मानते हुए कि यह `main.py` file में `app` नाम का object है (या कुछ अन्य variants में से कोई एक)।
@@ -95,18 +95,18 @@ entrypoint = "backend.main:app"
from backend.main import app
```
### path के साथ या `--entrypoint` CLI option के साथ `fastapi dev` { #fastapi-dev-with-path-or-with-entrypoint-cli-option }
### `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
$ uv run fastapi dev main.py
```
या, आप `fastapi dev` command को `--entrypoint` option भी pass कर सकते हैं:
```console
$ fastapi dev --entrypoint main:app
$ uv run fastapi dev --entrypoint main:app
```
लेकिन आपको हर बार `fastapi` command call करते समय सही path\entrypoint pass करना याद रखना होगा।
@@ -119,6 +119,10 @@ $ fastapi dev --entrypoint main:app
Default रूप से, **auto-reload** enabled होता है, जो आपके code में changes करने पर server को अपने-आप reload कर देता है। यह resource-intensive है और disabled होने की तुलना में कम stable हो सकता है। आपको इसे केवल development के लिए ही उपयोग करना चाहिए। यह IP address `127.0.0.1` पर भी listen करता है, जो आपकी machine का खुद से ही communicate करने वाला IP है (`localhost`)।
आपके ऐप को import करने से पहले, `fastapi dev` `FASTAPI_ENV` environment variable को `development` पर set करता है। अगर `FASTAPI_ENV` पहले से set है, तो इसकी मौजूदा value सुरक्षित रखी जाती है। इससे app startup code development-friendly व्यवहार चुन सकता है, जबकि आपको `staging` जैसा app-specific environment देने की अनुमति मिलती है।
Conventional `FASTAPI_ENV` values `development` और `production` हैं। `fastapi run` वर्तमान में `FASTAPI_ENV` को unchanged छोड़ देता है, इसलिए अगर आपके ऐप को production mode detect करने की ज़रूरत है तो इसे स्पष्ट रूप से set करें।
## `fastapi run` { #fastapi-run }
`fastapi run` execute करने से FastAPI production mode में शुरू होता है।
docs/hi/docs/features.md
+3 -3
View File
@@ -19,7 +19,7 @@ Interactive API documentation और exploration web user interfaces। क्
![Swagger UI इंटरैक्शन](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
* [**ReDoc**](https://github.com/Rebilly/ReDoc) के साथ वैकल्पिक API documentation।
* [**ReDoc**](https://github.com/Redocly/redoc) के साथ वैकल्पिक API documentation।
![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
@@ -159,7 +159,7 @@ FastAPI में एक बेहद आसान, लेकिन बेहद
## Starlette की विशेषताएँ { #starlette-features }
**FastAPI** [**Starlette**](https://www.starlette.dev/) के साथ पूरी तरह compatible है (और उसी पर आधारित है)। इसलिए, आपके पास जो भी अतिरिक्त Starlette code है, वह भी काम करेगा।
**FastAPI** [**Starlette**](https://starlette.dev/) के साथ पूरी तरह compatible है (और उसी पर आधारित है)। इसलिए, आपके पास जो भी अतिरिक्त Starlette code है, वह भी काम करेगा।
`FastAPI` वास्तव में `Starlette` का एक sub-class है। इसलिए, अगर आप पहले से Starlette जानते हैं या उपयोग करते हैं, तो अधिकांश functionality उसी तरह काम करेगी।
@@ -177,7 +177,7 @@ FastAPI में एक बेहद आसान, लेकिन बेहद
## Pydantic की विशेषताएँ { #pydantic-features }
**FastAPI** [**Pydantic**](https://docs.pydantic.dev/) के साथ पूरी तरह compatible है (और उसी पर आधारित है)। इसलिए, आपके पास जो भी अतिरिक्त Pydantic code है, वह भी काम करेगा।
**FastAPI** [**Pydantic**](https://pydantic.dev/docs/) के साथ पूरी तरह compatible है (और उसी पर आधारित है)। इसलिए, आपके पास जो भी अतिरिक्त Pydantic code है, वह भी काम करेगा।
इसमें Pydantic पर आधारित external libraries भी शामिल हैं, जैसे databases के लिए <abbr title="Object-Relational Mapper - ऑब्जेक्ट-रिलेशनल मैपर">ORM</abbr>s और <abbr title="Object-Document Mapper - ऑब्जेक्ट-डॉक्यूमेंट मैपर">ODM</abbr>s।
docs/hi/docs/help-fastapi.md
+7 -15
View File
@@ -45,20 +45,6 @@ Star जोड़ने से, अन्य users इसे अधिक आस
* [**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), उदाहरण के लिए:
@@ -68,7 +54,7 @@ Star जोड़ने से, अन्य users इसे अधिक आस
## Chat से जुड़ें { #join-the-chat }
👥 [Discord chat server](https://discord.gg/VQjSZaeJmf) 👥 से जुड़ें और FastAPI community में दूसरों के साथ बातचीत करें।
👥 [Discord chat server](https://discord.com/invite/VQjSZaeJmf) 👥 से जुड़ें और FastAPI community में दूसरों के साथ बातचीत करें।
/// tip | सुझाव
@@ -85,3 +71,9 @@ Chat का उपयोग केवल अन्य सामान्य ब
GitHub में, template आपको सही प्रश्न लिखने में मार्गदर्शन करेगा ताकि आप अधिक आसानी से अच्छा उत्तर पा सकें, या पूछने से पहले ही समस्या को स्वयं भी हल कर सकें।
Chat systems में बातचीत GitHub जितनी आसानी से searchable भी नहीं होती, वे खो जाती हैं।
## FastAPI Cloud आज़माएँ { #try-fastapi-cloud }
FastAPI और friends के लिए मुख्य funding [**FastAPI Cloud**](https://fastapicloud.com) से आती है, यह FastAPI applications को सरल और तेज़ तरीके से, एक ही command, `fastapi deploy`, के साथ deploy करने का platform है।
FastAPI Cloud उसी team द्वारा बनाया गया है जो FastAPI के पीछे है। आप इसे आज़मा सकते हैं और अपने projects के लिए इस पर विचार कर सकते हैं।
docs/hi/docs/history-design-future.md
+2 -2
View File
@@ -54,11 +54,11 @@
## Requirements { #requirements }
कई विकल्पों का परीक्षण करने के बाद, मैंने तय किया कि मैं इसके लाभों के लिए [**Pydantic**](https://docs.pydantic.dev/) का उपयोग करूँगा।
कई विकल्पों का परीक्षण करने के बाद, मैंने तय किया कि मैं इसके लाभों के लिए [**Pydantic**](https://pydantic.dev/docs/) का उपयोग करूँगा।
फिर मैंने इसमें योगदान दिया, ताकि इसे JSON Schema के साथ पूरी तरह compliant बनाया जा सके, constraint declarations को define करने के अलग-अलग तरीकों का समर्थन किया जा सके, और कई editors में tests के आधार पर editor support (type checks, autocompletion) को बेहतर बनाया जा सके।
Development के दौरान, मैंने [**Starlette**](https://www.starlette.dev/) में भी योगदान दिया, जो दूसरी मुख्य requirement थी।
Development के दौरान, मैंने [**Starlette**](https://starlette.dev/) में भी योगदान दिया, जो दूसरी मुख्य requirement थी।
## Development { #development }
docs/hi/docs/how-to/custom-request-and-route.md
+1 -1
View File
@@ -66,7 +66,7 @@
और ये दो चीजें, `scope` और `receive`, नई `Request` instance बनाने के लिए आवश्यक हैं।
`Request` के बारे में अधिक जानने के लिए [Requests के बारे में Starlette के docs](https://www.starlette.dev/requests/) देखें।
`Request` के बारे में अधिक जानने के लिए [Requests के बारे में Starlette के docs](https://starlette.dev/requests/) देखें।
///
docs/hi/docs/how-to/extending-openapi.md
+1 -1
View File
@@ -45,7 +45,7 @@ parameter `summary` OpenAPI 3.1.0 और उससे ऊपर में उप
ऊपर दी गई जानकारी का उपयोग करके, आप OpenAPI schema generate करने और अपनी ज़रूरत के अनुसार प्रत्येक हिस्से को override करने के लिए उसी utility function का उपयोग कर सकते हैं।
उदाहरण के लिए, आइए [custom logo शामिल करने के लिए ReDoc का OpenAPI extension](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo) जोड़ें।
उदाहरण के लिए, आइए [custom logo शामिल करने के लिए ReDoc का OpenAPI extension](https://github.com/Redocly/redoc/blob/main/docs/redoc-vendor-extensions.md#x-logo) जोड़ें।
### सामान्य **FastAPI** { #normal-fastapi }
docs/hi/docs/how-to/graphql.md
+1 -1
View File
@@ -21,7 +21,7 @@ Common **web APIs** की तुलना में इसके **advantages**
* [Strawberry](https://strawberry.rocks/) 🍓
* [FastAPI के लिए docs](https://strawberry.rocks/docs/integrations/fastapi) के साथ
* [Ariadne](https://ariadnegraphql.org/)
* [FastAPI के लिए docs](https://ariadnegraphql.org/docs/fastapi-integration) के साथ
* [FastAPI के लिए docs](https://ariadnegraphql.org/server/Integrations/fastapi-integration) के साथ
* [Tartiflette](https://tartiflette.io/)
* ASGI integration प्रदान करने के लिए [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) के साथ
* [Graphene](https://graphene-python.org/)
docs/hi/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
+1 -1
View File
@@ -24,7 +24,7 @@ Pydantic team ने **Python 3.14** से शुरू करते हुए,
## आधिकारिक गाइड { #official-guide }
Pydantic के पास v1 से v2 के लिए एक आधिकारिक [Migration Guide](https://docs.pydantic.dev/latest/migration/) है।
Pydantic के पास v1 से v2 के लिए एक आधिकारिक [Migration Guide](https://pydantic.dev/docs/validation/latest/get-started/migration/) है।
इसमें यह भी शामिल है कि क्या बदला है, validations अब कैसे अधिक सही और strict हैं, संभावित caveats आदि।
docs/hi/docs/index.md
+96 -100
View File
@@ -13,7 +13,7 @@ include_yaml:
<a href="https://fastapi.tiangolo.com/hi"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
</p>
<p align="center">
<em>FastAPI फ़्रेमवर्क, उच्च प्रदर्शन, सीखने में आसान, कोड लिखने में तेज़, प्रोडक्शन के लिए तैयार</em>
<em>FastAPI framework, उच्च प्रदर्शन, सीखने में आसान, कोड लिखने में तेज़, production के लिए तैयार</em>
</p>
<p align="center">
<a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster">
@@ -23,7 +23,7 @@ include_yaml:
<img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/fastapi.svg" alt="कवरेज">
</a>
<a href="https://pypi.org/project/fastapi">
<img src="https://img.shields.io/pypi/v/fastapi?color=%2334D058&label=pypi%20package" alt="पैकेज संस्करण">
<img src="https://img.shields.io/pypi/v/fastapi?color=%2334D058&label=pypi%20package" alt="package संस्करण">
</a>
<a href="https://pypi.org/project/fastapi">
<img src="https://img.shields.io/pypi/pyversions/fastapi.svg?color=%2334D058" alt="समर्थित Python संस्करण">
@@ -38,20 +38,20 @@ include_yaml:
---
FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्शन) वेब फ़्रेमवर्क है जो मानक Python type hints के आधार पर Python से APIs बनाने के लिए है।
FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्शन) web framework है जो standard Python type hints के आधार पर Python से APIs बनाने के लिए है।
मुख्य विशेषताएँ:
* **तेज़**: बहुत उच्च प्रदर्शन, **NodeJS** और **Go** के समकक्ष (Starlette और Pydantic की बदौलत)। [उपलब्ध सबसे तेज़ Python फ़्रेमवर्क्स में से एक](#performance)।
* **कोड लिखने में तेज़**: फ़ीचर्स विकसित करने की गति लगभग 200% से 300% तक बढ़ाएँ। *
* **कम बग्स**: मानवीय (डेवलपर) त्रुटियों में लगभग 40% की कमी। *
* **सहज**: बेहतरीन एडिटर सपोर्ट। हर जगह <dfn title="उर्फ़: ऑटो-कम्प्लीट, ऑटोकम्प्लीशन, IntelliSense">ऑटो-कम्प्लीट</dfn>। डिबगिंग में कम समय।
* **आसान**: इस्तेमाल और सीखने में आसान। दस्तावेज़ पढ़ने में कम समय।
* **संक्षिप्त**: कोड डुप्लीकेशन को न्यूनतम करें। प्रत्येक parameter declaration से कई फ़ीचर्स। कम बग्स।
* **मजबूत**: प्रोडक्शन-रेडी कोड प्राप्त करें। स्वतः इंटरैक्टिव दस्तावेज़ीकरण के साथ।
* **मानकों पर आधारित**: APIs के खुले मानकों पर आधारित (और पूर्णतः अनुकूल): [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (जिसे पहले Swagger कहा जाता था) और [JSON Schema](https://json-schema.org/)।
* **तेज़**: बहुत उच्च प्रदर्शन, **NodeJS** और **Go** के समकक्ष (Starlette और Pydantic की बदौलत)। [उपलब्ध सबसे तेज़ Python frameworks में से एक](#performance)।
* **कोड लिखने में तेज़**: features विकसित करने की गति लगभग 200% से 300% तक बढ़ाएँ। *
* **कम बग्स**: मानवीय (developer) त्रुटियों में लगभग 40% की कमी। *
* **सहज**: बेहतरीन editor support। हर जगह <dfn title="जिसे auto-complete, autocompletion, IntelliSense भी कहा जाता है">Completion</dfn>। डिबगिंग में कम समय।
* **आसान**: इस्तेमाल और सीखने में आसान होने के लिए डिज़ाइन किया गया। docs पढ़ने में कम समय।
* **संक्षिप्त**: कोड डुप्लीकेशन को न्यूनतम करें। प्रत्येक parameter declaration से कई features। कम बग्स।
* **मजबूत**: production-ready कोड प्राप्त करें। स्वतः इंटरैक्टिव दस्तावेज़ीकरण के साथ।
* **standards-आधारित**: APIs के open standards पर आधारित (और पूर्णतः अनुकूल): [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (जिसे पहले Swagger कहा जाता था) और [JSON Schema](https://json-schema.org/)।
<small>* आंतरिक डेवलपमेंट टीम द्वारा प्रोडक्शन ऐप्स बनाते समय किए गए परीक्षणों के आधार पर अनुमान।</small>
<small>* आंतरिक development team द्वारा production applications बनाते समय किए गए परीक्षणों के आधार पर अनुमान।</small>
## प्रायोजक { #sponsors }
@@ -105,19 +105,19 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
</div>
<div class="fastapi-opinions__panel" id="fo-panel-microsoft" role="tabpanel" aria-labelledby="fo-tab-microsoft" tabindex="0">
<blockquote class="fastapi-opinions__quote">"मैं इन दिनों <strong>FastAPI</strong> का बहुत उपयोग कर रहा/रही हूँ। वास्तव में मैं अपनी टीम की <strong>Microsoft में ML सेवाओं</strong> के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य <strong>Windows</strong> प्रोडक्ट और कुछ <strong>Office</strong> प्रोडक्ट्स में इंटीग्रेट किया जा रहा है।"</blockquote>
<blockquote class="fastapi-opinions__quote">"मैं इन दिनों <strong>FastAPI</strong> का बहुत उपयोग कर रहा/रही हूँ। वास्तव में मैं अपनी team की <strong>Microsoft में ML सेवाओं</strong> के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य <strong>Windows</strong> product और कुछ <strong>Office</strong> products में इंटीग्रेट किया जा रहा है।"</blockquote>
<div class="fastapi-opinions__attr">— कबीर खान, <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26">(संदर्भ)</a></div>
</div>
<div class="fastapi-opinions__panel" id="fo-panel-uber" role="tabpanel" aria-labelledby="fo-tab-uber" tabindex="0" hidden>
<blockquote class="fastapi-opinions__quote">"हमने <strong>FastAPI</strong> लाइब्रेरी अपनाई ताकि एक <strong>REST</strong> सर्वर स्पॉन किया जा सके जिसे <strong>अन्दाज़ों/अनुमानों</strong> को प्राप्त करने के लिए क्वेरी किया जा सके।" <em>[Ludwig के लिए]</em></blockquote>
<div class="fastapi-opinions__attr">— पिएरो मोलिनो, यारोस्लाव डुडिन, साई सुमंत मिर्याला, <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/">(संदर्भ)</a></div>
<blockquote class="fastapi-opinions__quote">"हमने <strong>FastAPI</strong> लाइब्रेरी अपनाई ताकि एक <strong>REST</strong> सर्वर स्पॉन किया जा सके जिसे <strong>अन्दाज़ों/अनुमानों</strong> को प्राप्त करने के लिए query किया जा सके।" <em>[Ludwig के लिए]</em></blockquote>
<div class="fastapi-opinions__attr">— पिएरो मोलिनो, यारोस्लाव डुडिन, साई सुमंत मिर्याला, <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/">(संदर्भ)</a></div>
</div>
<div class="fastapi-opinions__panel" id="fo-panel-netflix" role="tabpanel" aria-labelledby="fo-tab-netflix" tabindex="0" hidden>
<blockquote class="fastapi-opinions__quote">"<strong>Netflix</strong> हमारे <strong>संकट प्रबंधन</strong> ऑर्केस्ट्रेशन फ़्रेमवर्क: <strong>Dispatch</strong> के ओपन-सोर्स रिलीज़ की घोषणा करते हुए प्रसन्न है!" <em>[FastAPI के साथ बनाया गया]</em></blockquote>
<blockquote class="fastapi-opinions__quote">"<strong>Netflix</strong> हमारे <strong>संकट प्रबंधन</strong> ऑर्केस्ट्रेशन framework: <strong>Dispatch</strong> के ओपन-सोर्स रिलीज़ की घोषणा करते हुए प्रसन्न है!" <em>[FastAPI के साथ बनाया गया]</em></blockquote>
<div class="fastapi-opinions__attr">— केविन ग्लिसन, मार्क विलानोवा, फॉरेस्ट मॉन्सेन, <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072">(संदर्भ)</a></div>
</div>
<div class="fastapi-opinions__panel" id="fo-panel-cisco" role="tabpanel" aria-labelledby="fo-tab-cisco" tabindex="0" hidden>
<blockquote class="fastapi-opinions__quote">"यदि कोई प्रोडक्शन Python API बनाना चाहता है, तो मैं <strong>FastAPI</strong> की अत्यधिक अनुशंसा करूंगा/करूंगी। यह <strong>सुंदरता से डिज़ाइन</strong> किया गया है, <strong>उपयोग में सरल</strong> है और <strong>बेहद स्केलेबल</strong> है — यह हमारी API-फर्स्ट डेवलपमेंट रणनीति का <strong>मुख्य घटक</strong> बन गया है।"</blockquote>
<blockquote class="fastapi-opinions__quote">"यदि कोई production Python API बनाना चाहता है, तो मैं <strong>FastAPI</strong> की अत्यधिक अनुशंसा करूंगा/करूंगी। यह <strong>सुंदरता से डिज़ाइन</strong> किया गया है, <strong>उपयोग में सरल</strong> है और <strong>बेहद स्केलेबल</strong> है — यह हमारी API-फर्स्ट development रणनीति का <strong>मुख्य घटक</strong> बन गया है।"</blockquote>
<div class="fastapi-opinions__attr">— डीयोन पिल्सबरी, <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/">(संदर्भ)</a></div>
</div>
</div>
@@ -125,25 +125,25 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
<div class="only-github" markdown="1">
"_[...] मैं इन दिनों **FastAPI** का बहुत उपयोग कर रहा/रही हूँ। [...] वास्तव में मैं अपनी टीम की **Microsoft में ML सेवाओं** के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य **Windows** प्रोडक्ट और कुछ **Office** प्रोडक्ट्स में इंटीग्रेट किया जा रहा है._"
"_[...] मैं इन दिनों **FastAPI** का बहुत उपयोग कर रहा/रही हूँ। [...] वास्तव में मैं अपनी team की **Microsoft में ML सेवाओं** के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य **Windows** product और कुछ **Office** products में इंटीग्रेट किया जा रहा है._"
<div style="text-align: right; margin-right: 10%;">कबीर खान - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26"><small>(संदर्भ)</small></a></div>
---
"_हमने **FastAPI** लाइब्रेरी अपनाई ताकि एक **REST** सर्वर स्पॉन किया जा सके जिसे **अनुमानों** को प्राप्त करने के लिए क्वेरी किया जा सके। [Ludwig के लिए]_"
"_हमने **FastAPI** लाइब्रेरी अपनाई ताकि एक **REST** सर्वर स्पॉन किया जा सके जिसे **अनुमानों** को प्राप्त करने के लिए query किया जा सके। [Ludwig के लिए]_"
<div style="text-align: right; margin-right: 10%;">पिएरो मोलिनो, यारोस्लाव डुडिन, और साई सुमंत मिर्याला - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(संदर्भ)</small></a></div>
<div style="text-align: right; margin-right: 10%;">पिएरो मोलिनो, यारोस्लाव डुडिन, और साई सुमंत मिर्याला - <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/"><small>(संदर्भ)</small></a></div>
---
"_**Netflix** हमारे **संकट प्रबंधन** ऑर्केस्ट्रेशन फ़्रेमवर्क: **Dispatch** के ओपन-सोर्स रिलीज़ की घोषणा करते हुए प्रसन्न है! [**FastAPI** के साथ बनाया गया]_"
"_**Netflix** हमारे **संकट प्रबंधन** ऑर्केस्ट्रेशन framework: **Dispatch** के ओपन-सोर्स रिलीज़ की घोषणा करते हुए प्रसन्न है! [**FastAPI** के साथ बनाया गया]_"
<div style="text-align: right; margin-right: 10%;">केविन ग्लिसन, मार्क विलानोवा, फॉरेस्ट मॉन्सेन - <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072"><small>(संदर्भ)</small></a></div>
---
"_यदि कोई प्रोडक्शन Python API बनाना चाहता है, तो मैं **FastAPI** की अत्यधिक अनुशंसा करूंगा/करूंगी। यह **सुंदरता से डिज़ाइन** किया गया है, **उपयोग में सरल** है और **बेहद स्केलेबल** है, यह हमारी API-फ़र्स्ट डेवलपमेंट रणनीति का **मुख्य घटक** बन गया है और हमारे Virtual TAC Engineer जैसे कई ऑटोमेशन्स और सेवाओं को चला रहा है._"
"_यदि कोई production Python API बनाना चाहता है, तो मैं **FastAPI** की अत्यधिक अनुशंसा करूंगा/करूंगी। यह **सुंदरता से डिज़ाइन** किया गया है, **उपयोग में सरल** है और **बेहद स्केलेबल** है, यह हमारी API first development रणनीति का **मुख्य घटक** बन गया है और हमारे Virtual TAC Engineer जैसे कई ऑटोमेशन्स और सेवाओं को चला रहा है._"
<div style="text-align: right; margin-right: 10%;">डीयोन पिल्सबरी - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/"><small>(संदर्भ)</small></a></div>
@@ -151,12 +151,6 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
</div>
## FastAPI कॉन्फ़ { #fastapi-conf }
[**FastAPI Conf '26**](https://fastapiconf.com) **28 अक्टूबर, 2026** को **एम्स्टर्डम, नीदरलैंड्स** में हो रही है। सब कुछ FastAPI के बारे में, सीधे स्रोत से। 🎤
<a class="fastapi-feature-banner" href="https://fastapiconf.com"><img src="https://fastapi.tiangolo.com/img/fastapi-conf.jpeg" alt="FastAPI Conf '26 - 28 अक्टूबर, 2026 - एम्स्टर्डम, NL"></a>
## FastAPI मिनी डॉक्यूमेंट्री { #fastapi-mini-documentary }
साल 2025 के अंत में एक [FastAPI मिनी डॉक्यूमेंट्री](https://www.youtube.com/watch?v=mpR8ngthqiE) रिलीज़ हुई, आप इसे ऑनलाइन देख सकते हैं:
@@ -167,7 +161,7 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
<a href="https://typer.tiangolo.com"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
यदि आप वेब API के बजाय टर्मिनल में उपयोग होने वाला <abbr title="Command Line Interface - आदेश पंक्ति इंटरफ़ेस">CLI</abbr> ऐप बना रहे हैं, तो [**Typer**](https://typer.tiangolo.com/) देखें।
यदि आप web API के बजाय टर्मिनल में उपयोग होने वाला <abbr title="Command Line Interface - कमांड लाइन इंटरफ़ेस">CLI</abbr> ऐप बना रहे हैं, तो [**Typer**](https://typer.tiangolo.com/) देखें।
**Typer**, FastAPI का छोटा भाई/बहन है। और इसका उद्देश्य **CLIs का FastAPI** होना है। ⌨️ 🚀
@@ -175,17 +169,17 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
FastAPI दिग्गजों के कंधों पर खड़ा है:
* वेब हिस्सों के लिए [Starlette](https://www.starlette.dev/)।
* डेटा हिस्सों के लिए [Pydantic](https://docs.pydantic.dev/)।
* web हिस्सों के लिए [Starlette](https://starlette.dev/)।
* data हिस्सों के लिए [Pydantic](https://pydantic.dev/docs/)।
## स्थापना { #installation }
## Installation { #installation }
एक [वर्चुअल एन्वायरनमेंट](https://fastapi.tiangolo.com/hi/virtual-environments/) बनाएँ और सक्रिय करें, और फिर FastAPI स्थापित करें:
पहले, [`uv` install करें](https://docs.astral.sh/uv/getting-started/installation/), और फिर अपने project में FastAPI जोड़ें:
<div class="termy">
```console
$ pip install "fastapi[standard]"
$ uv add "fastapi[standard]"
---> 100%
```
@@ -194,11 +188,13 @@ $ pip install "fastapi[standard]"
**नोट**: सुनिश्चित करें कि आप सभी टर्मिनलों में काम करने के लिए `"fastapi[standard]"` को उद्धरण-चिह्नों में रखें।
यदि आप `pip` का उपयोग करना पसंद करते हैं, तो virtual environment के अंदर `fastapi[standard]` install करें। वैकल्पिक चरणों के लिए [installation guide](tutorial/#install-fastapi) देखें।
## उदाहरण { #example }
### इसे बनाएँ { #create-it }
`main.py` फ़ाइल बनाएँ और इसमें लिखें:
`main.py` file बनाएँ, जिसमें:
```Python
from fastapi import FastAPI
@@ -239,7 +235,7 @@ async def read_item(item_id: int, q: str | None = None):
**नोट**:
यदि आप नहीं जानते, तो _"जल्दी में?"_ सेक्शन देखें: दस्तावेज़ में [`async` और `await`](https://fastapi.tiangolo.com/hi/async/#in-a-hurry) के बारे में।
यदि आप नहीं जानते, तो docs में [`async` और `await`](https://fastapi.tiangolo.com/hi/async/#in-a-hurry) के बारे में _"जल्दी में?"_ section देखें।
</details>
@@ -250,7 +246,7 @@ async def read_item(item_id: int, q: str | None = None):
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
╭────────── FastAPI CLI - Development mode ───────────╮
│ │
@@ -277,11 +273,11 @@ INFO: Application startup complete.
<details markdown="1">
<summary><code>fastapi dev</code> कमांड के बारे में...</summary>
`fastapi dev` कमांड आपका `main.py` फ़ाइल स्वतः पढ़ता है, उसमें **FastAPI** ऐप का पता लगाता है, और [Uvicorn](https://www.uvicorn.dev) का उपयोग करके सर्वर शुरू करता है।
`fastapi dev` कमांड आपका `main.py` file स्वतः पढ़ता है, उसमें **FastAPI** ऐप का पता लगाता है, और [Uvicorn](https://uvicorn.dev) का उपयोग करके सर्वर शुरू करता है।
डिफ़ॉल्ट रूप से, `fastapi dev` लोकल डेवलपमेंट के लिए auto-reload सक्षम करके शुरू होगा।
default रूप से, `fastapi dev` लोकल development के लिए auto-reload सक्षम करके शुरू होगा।
आप इसके बारे में और पढ़ सकते हैं: [FastAPI CLI दस्तावेज़](https://fastapi.tiangolo.com/hi/fastapi-cli/) में।
आप इसके बारे में और पढ़ सकते हैं: [FastAPI CLI docs](https://fastapi.tiangolo.com/hi/fastapi-cli/) में।
</details>
@@ -289,7 +285,7 @@ INFO: Application startup complete.
अपने ब्राउज़र में [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery) खोलें।
आपको JSON प्रतिक्रिया इस प्रकार दिखेगी:
आपको JSON response इस प्रकार दिखेगी:
```JSON
{"item_id": 5, "q": "somequery"}
@@ -297,7 +293,7 @@ INFO: Application startup complete.
आपने पहले ही एक API बना ली है जो:
* _paths_ `/` और `/items/{item_id}` पर HTTP अनुरोध स्वीकार करती है।
* _paths_ `/` और `/items/{item_id}` पर HTTP requests स्वीकार करती है।
* दोनों _paths_ `GET` <em>operations</em> लेती हैं (जिन्हें HTTP _methods_ भी कहा जाता है)।
* _path_ `/items/{item_id}` में एक _path parameter_ `item_id` है जो `int` होना चाहिए।
* _path_ `/items/{item_id}` में एक वैकल्पिक `str` _query parameter_ `q` है।
@@ -314,15 +310,15 @@ INFO: Application startup complete.
और अब, [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) पर जाएँ।
आपको वैकल्पिक स्वचालित दस्तावेज़ीकरण दिखेगा (जो [ReDoc](https://github.com/Rebilly/ReDoc) द्वारा प्रदान किया जाता है):
आपको वैकल्पिक स्वचालित दस्तावेज़ीकरण दिखेगा (जो [ReDoc](https://github.com/Redocly/redoc) द्वारा प्रदान किया जाता है):
![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
## उदाहरण उन्नयन { #example-upgrade }
अब `PUT` अनुरोध से body प्राप्त करने के लिए `main.py` फ़ाइल संशोधित करें।
अब `PUT` request से body प्राप्त करने के लिए `main.py` file संशोधित करें।
Pydantic की बदौलत, body को मानक Python प्रकारों से घोषित करें।
Pydantic की बदौलत, body को standard Python प्रकारों से घोषित करें।
```Python hl_lines="2 7-10 23-25"
from fastapi import FastAPI
@@ -378,15 +374,15 @@ def update_item(item_id: int, item: Item):
![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
### पुनरावलोकन { #recap }
### Recap { #recap }
संक्षेप में, आप parameters, body, आदि के प्रकार फ़ंक्शन parameters के रूप में **एक बार** घोषित करते हैं।
संक्षेप में, आप parameters, body, आदि के प्रकार function parameters के रूप में **एक बार** घोषित करते हैं।
आप यह मानक आधुनिक Python प्रकारों से करते हैं।
आप यह standard आधुनिक Python प्रकारों से करते हैं।
आपको किसी नई सिंटैक्स, किसी विशेष लाइब्रेरी के methods या classes, आदि सीखने की आवश्यकता नहीं है।
बस मानक **Python**।
बस standard **Python**।
उदाहरण के लिए, एक `int` के लिए:
@@ -394,7 +390,7 @@ def update_item(item_id: int, item: Item):
item_id: int
```
या एक अधिक जटिल `Item` मॉडल के लिए:
या एक अधिक जटिल `Item` model के लिए:
```Python
item: Item
@@ -402,13 +398,13 @@ item: Item
...और केवल उसी एक घोषणा के साथ आपको मिलता है:
* एडिटर सपोर्ट, जिसमें शामिल है:
* कम्प्लीशन।
* प्रकार जाँच।
* डेटा का वैधीकरण:
* जब डेटा अमान्य हो तो स्वतः और स्पष्ट त्रुटियाँ।
* Editor support, जिसमें शामिल है:
* Completion।
* Type checks।
* data का वैधीकरण:
* जब data अमान्य हो तो स्वतः और स्पष्ट त्रुटियाँ।
* गहराई से nested JSON objects के लिए भी वैधीकरण।
* इनपुट डेटा का <dfn title="उर्फ़: सीरियलाइज़ेशन, पार्सिंग, मार्शलिंग">रूपांतरण</dfn>: नेटवर्क से Python डेटा और प्रकारों में। इनमें से पढ़ना:
* इनपुट data का <dfn title="जिसे serialization, parsing, marshalling भी कहा जाता है">Conversion</dfn>: नेटवर्क से Python data और प्रकारों में। इनमें से पढ़ना:
* JSON।
* Path parameters।
* Query parameters।
@@ -416,11 +412,11 @@ item: Item
* Headers।
* Forms।
* Files।
* आउटपुट डेटा का <dfn title="उर्फ़: सीरियलाइज़ेशन, पार्सिंग, मार्शलिंग">रूपांतरण</dfn>: Python डेटा और प्रकारों से नेटवर्क डेटा (JSON के रूप में) में:
* Python प्रकारों का रूपांतरण (`str`, `int`, `float`, `bool`, `list`, आदि)।
* आउटपुट data का <dfn title="जिसे serialization, parsing, marshalling भी कहा जाता है">Conversion</dfn>: Python data और प्रकारों से नेटवर्क data (JSON के रूप में) में:
* Python प्रकारों का conversion (`str`, `int`, `float`, `bool`, `list`, आदि)।
* `datetime` ऑब्जेक्ट्स।
* `UUID` ऑब्जेक्ट्स।
* डेटाबेस मॉडल्स।
* डेटाबेस models।
* ...और बहुत कुछ।
* स्वचालित इंटरैक्टिव API दस्तावेज़ीकरण, जिनमें 2 वैकल्पिक यूज़र इंटरफ़ेस शामिल हैं:
* Swagger UI।
@@ -430,22 +426,22 @@ item: Item
पिछले कोड उदाहरण पर लौटते हुए, **FastAPI** यह करेगा:
* `GET` और `PUT` अनुरोधों के लिए path में `item_id` है, यह सत्यापित करेगा।
* `GET` और `PUT` अनुरोधों के लिए `item_id` का प्रकार `int` है, यह सत्यापित करेगा।
* `GET` और `PUT` requests के लिए path में `item_id` है, यह सत्यापित करेगा।
* `GET` और `PUT` requests के लिए `item_id` का प्रकार `int` है, यह सत्यापित करेगा।
* यदि नहीं है, तो क्लाइंट को एक उपयोगी, स्पष्ट त्रुटि दिखाई देगी।
* `GET` अनुरोधों के लिए यह जाँच करेगा कि `q` नाम का एक वैकल्पिक query parameter है (जैसे `http://127.0.0.1:8000/items/foo?q=somequery`)।
* `GET` requests के लिए यह जाँच करेगा कि `q` नाम का एक वैकल्पिक query parameter है (जैसे `http://127.0.0.1:8000/items/foo?q=somequery`)।
* क्योंकि `q` parameter `= None` के साथ घोषित है, यह वैकल्पिक है।
* `None` के बिना यह आवश्यक होता (जैसे `PUT` के मामले में body आवश्यक है)।
* `/items/{item_id}` पर `PUT` अनुरोधों के लिए, body को JSON के रूप में पढ़ेगा:
* यह जाँचेगा कि एक आवश्यक attribute `name` है जो `str` होना चाहिए।
* यह जाँचेगा कि एक आवश्यक attribute `price` है जो `float` होना चाहिए।
* `None` के बिना यह required होता (जैसे `PUT` के मामले में body required है)।
* `/items/{item_id}` पर `PUT` requests के लिए, body को JSON के रूप में पढ़ेगा:
* यह जाँचेगा कि एक required attribute `name` है जो `str` होना चाहिए।
* यह जाँचेगा कि एक required attribute `price` है जो `float` होना चाहिए।
* यह जाँचेगा कि एक वैकल्पिक attribute `is_offer` है, जो यदि मौजूद है तो `bool` होना चाहिए।
* यह सब गहराई से nested JSON objects के लिए भी काम करेगा।
* JSON से और JSON में स्वतः रूपांतरण।
* JSON से और JSON में स्वतः convert करेगा।
* हर चीज़ को OpenAPI के साथ दस्तावेज़ित करेगा, जिसे निम्न द्वारा उपयोग किया जा सकता है:
* इंटरैक्टिव दस्तावेज़ीकरण प्रणालियाँ।
* कई भाषाओं के लिए स्वचालित क्लाइंट कोड जनरेशन प्रणालियाँ।
* सीधे 2 इंटरैक्टिव दस्तावेज़ीकरण वेब इंटरफेसेज़ प्रदान करेगा।
* सीधे 2 इंटरैक्टिव दस्तावेज़ीकरण web interfaces प्रदान करेगा।
---
@@ -469,35 +465,35 @@ item: Item
... "item_price": item.price ...
```
...और देखें कि आपका एडिटर attributes को कैसे auto-complete करेगा और उनके प्रकार जानेगा:
...और देखें कि आपका editor attributes को कैसे auto-complete करेगा और उनके प्रकार जानेगा:
![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
अधिक फ़ीचर्स सहित एक अधिक सम्पूर्ण उदाहरण के लिए, <a href="https://fastapi.tiangolo.com/hi/tutorial/">ट्यूटोरियल - यूज़र गाइड</a> देखें।
अधिक features सहित एक अधिक सम्पूर्ण उदाहरण के लिए, <a href="https://fastapi.tiangolo.com/hi/tutorial/">ट्यूटोरियल - यूज़र गाइड</a> देखें।
**स्पॉइलर अलर्ट**: ट्यूटोरियल - यूज़र गाइड में शामिल है:
* विभिन्न स्थानों से **parameters** की घोषणा: **headers**, **cookies**, **form fields** और **files**।
* `maximum_length` या `regex` जैसी **validation constraints** कैसे सेट करें।
* एक बहुत शक्तिशाली और उपयोग में आसान **<dfn title="उर्फ़: कॉम्पोनेंट्स, रिसोर्सेज़, प्रोवाइडर्स, सर्विसेज़, इंजेक्टेबल्स">डिपेंडेंसी इंजेक्शन</dfn>** सिस्टम।
* एक बहुत शक्तिशाली और उपयोग में आसान **<dfn title="जिन्हें components, resources, providers, services, injectables भी कहा जाता है">Dependency Injection</dfn>** सिस्टम।
* सुरक्षा और प्रमाणीकरण, जिसमें **OAuth2** के साथ **JWT tokens** और **HTTP Basic** auth का समर्थन शामिल है।
* **गहराई से nested JSON मॉडल्स** घोषित करने की अधिक उन्नत (पर समान रूप से आसान) तकनीकें (Pydantic की बदौलत)।
* **गहराई से nested JSON models** घोषित करने की अधिक उन्नत (पर समान रूप से आसान) तकनीकें (Pydantic की बदौलत)।
* [Strawberry](https://strawberry.rocks) और अन्य लाइब्रेरीज़ के साथ **GraphQL** एकीकरण।
* कई अतिरिक्त फ़ीचर्स (Starlette की बदौलत) जैसे:
* कई अतिरिक्त features (Starlette की बदौलत) जैसे:
* **WebSockets**
* HTTPX और `pytest` पर आधारित अत्यंत आसान टेस्ट्स
* **CORS**
* **Cookie Sessions**
* ...आदि।
### अपनी ऐप परिनियोजित करें (वैकल्पिक) { #deploy-your-app-optional }
### अपनी ऐप deploy करें (वैकल्पिक) { #deploy-your-app-optional }
आप वैकल्पिक रूप से अपनी FastAPI ऐप को [FastAPI Cloud](https://fastapicloud.com) पर एक ही कमांड से डिप्लॉय कर सकते हैं। 🚀
आप वैकल्पिक रूप से अपनी FastAPI ऐप को [FastAPI Cloud](https://fastapicloud.com) पर एक ही कमांड से deploy कर सकते हैं। 🚀
<div class="termy">
```console
$ fastapi deploy
$ uv run fastapi deploy
Deploying to FastAPI Cloud...
@@ -508,31 +504,31 @@ Deploying to FastAPI Cloud...
</div>
CLI आपकी FastAPI एप्लिकेशन को स्वतः पहचान लेगा और उसे क्लाउड पर डिप्लॉय करेगा। यदि आप logged in नहीं हैं, तो प्रमाणीकरण प्रक्रिया पूरी करने के लिए आपका ब्राउज़र खुलेगा।
CLI आपकी FastAPI application को स्वतः पहचान लेगा और उसे क्लाउड पर deploy करेगा। यदि आप logged in नहीं हैं, तो प्रमाणीकरण प्रक्रिया पूरी करने के लिए आपका ब्राउज़र खुलेगा।
बस इतना ही! अब आप उस URL पर अपनी ऐप एक्सेस कर सकते हैं। ✨
#### FastAPI Cloud के बारे में { #about-fastapi-cloud }
**[FastAPI Cloud](https://fastapicloud.com)** को **FastAPI** के ही लेखक और टीम ने बनाया है।
**[FastAPI Cloud](https://fastapicloud.com)** को **FastAPI** के ही लेखक और team ने बनाया है।
यह न्यूनतम प्रयास में किसी API को **बनाने**, **डिप्लॉय** करने और **एक्सेस** करने की प्रक्रिया को सरल बनाता है।
यह न्यूनतम प्रयास में किसी API को **बनाने**, **deploy** करने और **एक्सेस** करने की प्रक्रिया को सरल बनाता है।
यह FastAPI के साथ ऐप्स बनाने के उसी **डेवलपर अनुभव** को उन्हें क्लाउड में **डिप्लॉय** करने तक लाता है। 🎉
यह FastAPI के साथ ऐप्स बनाने के उसी **developer experience** को उन्हें क्लाउड में **deploy** करने तक लाता है। 🎉
FastAPI Cloud, *FastAPI and friends* ओपन सोर्स प्रोजेक्ट्स के लिए मुख्य प्रायोजक और फंडिंग प्रदाता है। ✨
FastAPI Cloud, *FastAPI and friends* ओपन सोर्स projects के लिए मुख्य प्रायोजक और फंडिंग प्रदाता है। ✨
#### अन्य क्लाउड प्रदाताओं पर डिप्लॉय करें { #deploy-to-other-cloud-providers }
#### अन्य क्लाउड प्रदाताओं पर deploy करें { #deploy-to-other-cloud-providers }
FastAPI ओपन सोर्स है और मानकों पर आधारित है। आप FastAPI ऐप्स को किसी भी क्लाउड प्रदाता पर डिप्लॉय कर सकते हैं।
FastAPI ओपन सोर्स है और standards पर आधारित है। आप FastAPI ऐप्स को किसी भी क्लाउड प्रदाता पर deploy कर सकते हैं।
अपने क्लाउड प्रदाता के गाइड्स का पालन करें और उनके साथ FastAPI ऐप्स डिप्लॉय करें। 🤓
अपने क्लाउड प्रदाता के गाइड्स का पालन करें और उनके साथ FastAPI ऐप्स deploy करें। 🤓
## प्रदर्शन { #performance }
स्वतंत्र TechEmpower बेंचमार्क दिखाते हैं कि Uvicorn के तहत चलने वाले **FastAPI** एप्लीकेशन्स [उपलब्ध सबसे तेज़ Python फ़्रेमवर्क्स में से एक](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7) हैं, केवल Starlette और Uvicorn (जो FastAPI द्वारा आंतरिक रूप से उपयोग किए जाते हैं) से नीचे। (*)
स्वतंत्र TechEmpower बेंचमार्क दिखाते हैं कि Uvicorn के तहत चलने वाले **FastAPI** applications [उपलब्ध सबसे तेज़ Python frameworks में से एक](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7) हैं, केवल Starlette और Uvicorn (जो FastAPI द्वारा आंतरिक रूप से उपयोग किए जाते हैं) से नीचे। (*)
इसके बारे में अधिक समझने के लिए, [बेंचमार्क्स](https://fastapi.tiangolo.com/hi/benchmarks/) सेक्शन देखें।
इसके बारे में अधिक समझने के लिए, [बेंचमार्क्स](https://fastapi.tiangolo.com/hi/benchmarks/) section देखें।
## निर्भरताएँ { #dependencies }
@@ -540,7 +536,7 @@ FastAPI, Pydantic और Starlette पर निर्भर करता है
### `standard` निर्भरताएँ { #standard-dependencies }
जब आप `pip install "fastapi[standard]"` के साथ FastAPI स्थापित करते हैं, तो यह `standard` समूह की वैकल्पिक निर्भरताओं के साथ आता है:
जब आप `uv add "fastapi[standard]"` के साथ FastAPI install करते हैं, तो यह `standard` समूह की वैकल्पिक निर्भरताओं के साथ आता है:
Pydantic द्वारा उपयोग किया गया:
@@ -548,38 +544,38 @@ Pydantic द्वारा उपयोग किया गया:
Starlette द्वारा उपयोग किया गया:
* [`httpx`](https://www.python-httpx.org) - यदि आप `TestClient` का उपयोग करना चाहते हैं तो आवश्यक।
* [`jinja2`](https://jinja.palletsprojects.com) - यदि आप डिफ़ॉल्ट टेम्पलेट कॉन्फ़िगरेशन का उपयोग करना चाहते हैं तो आवश्यक।
* [`python-multipart`](https://github.com/Kludex/python-multipart) - यदि आप फॉर्म <dfn title="HTTP अनुरोध से आने वाली स्ट्रिंग को Python डेटा में बदलना">"पार्सिंग"</dfn> का समर्थन करना चाहते हैं, `request.form()` के साथ, तो आवश्यक।
* [`httpx`](https://www.python-httpx.org) - यदि आप `TestClient` का उपयोग करना चाहते हैं तो required।
* [`jinja2`](https://jinja.palletsprojects.com) - यदि आप default टेम्पलेट कॉन्फ़िगरेशन का उपयोग करना चाहते हैं तो required।
* [`python-multipart`](https://github.com/Kludex/python-multipart) - यदि आप form <dfn title="HTTP request से आने वाली string को Python data में convert करना">"parsing"</dfn> का समर्थन करना चाहते हैं, `request.form()` के साथ, तो required।
FastAPI द्वारा उपयोग किया गया:
* [`uvicorn`](https://www.uvicorn.dev) - वह सर्वर जो आपकी एप्लिकेशन को लोड और सर्व करता है। इसमें `uvicorn[standard]` शामिल है, जिसमें उच्च-प्रदर्शन सर्विंग के लिए कुछ निर्भरताएँ (जैसे `uvloop`) शामिल हैं।
* [`uvicorn`](https://uvicorn.dev) - उस सर्वर के लिए जो आपकी application को लोड और सर्व करता है। इसमें `uvicorn[standard]` शामिल है, जिसमें high performance serving के लिए कुछ निर्भरताएँ (जैसे `uvloop`) शामिल हैं।
* `fastapi-cli[standard]` - `fastapi` कमांड प्रदान करने के लिए।
* इसमें `fastapi-cloud-cli` शामिल है, जो आपको अपनी FastAPI एप्लिकेशन को [FastAPI Cloud](https://fastapicloud.com) पर डिप्लॉय करने की अनुमति देता है।
* इसमें `fastapi-cloud-cli` शामिल है, जो आपको अपनी FastAPI application को [FastAPI Cloud](https://fastapicloud.com) पर deploy करने की अनुमति देता है।
### `standard` निर्भरताओं के बिना { #without-standard-dependencies }
यदि आप `standard` वैकल्पिक निर्भरताओं को शामिल नहीं करना चाहते, तो आप `pip install fastapi` के साथ स्थापित कर सकते हैं, `pip install "fastapi[standard]"` के बजाय।
यदि आप `standard` वैकल्पिक निर्भरताओं को शामिल नहीं करना चाहते, तो आप `uv add "fastapi[standard]"` के बजाय `uv add fastapi` के साथ install कर सकते हैं।
### `fastapi-cloud-cli` के बिना { #without-fastapi-cloud-cli }
यदि आप standard निर्भरताओं के साथ लेकिन `fastapi-cloud-cli` के बिना FastAPI स्थापित करना चाहते हैं, तो `pip install "fastapi[standard-no-fastapi-cloud-cli]"` के साथ स्थापित कर सकते हैं।
यदि आप standard निर्भरताओं के साथ लेकिन `fastapi-cloud-cli` के बिना FastAPI install करना चाहते हैं, तो `uv add "fastapi[standard-no-fastapi-cloud-cli]"` के साथ install कर सकते हैं।
### अतिरिक्त वैकल्पिक निर्भरताएँ { #additional-optional-dependencies }
कुछ अतिरिक्त निर्भरताएँ हैं जिन्हें आप स्थापित करना चाहेंगे।
कुछ अतिरिक्त निर्भरताएँ हैं जिन्हें आप install करना चाहेंगे।
अतिरिक्त वैकल्पिक Pydantic निर्भरताएँ:
* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - सेटिंग्स प्रबंधन के लिए।
* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - Pydantic के साथ उपयोग करने के लिए अतिरिक्त प्रकारों हेतु।
* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) - सेटिंग्स प्रबंधन के लिए।
* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) - Pydantic के साथ उपयोग करने के लिए अतिरिक्त प्रकारों हेतु।
अतिरिक्त वैकल्पिक FastAPI निर्भरताएँ:
* [`orjson`](https://github.com/ijl/orjson) - यदि आप `ORJSONResponse` उपयोग करना चाहते हैं तो आवश्यक।
* [`ujson`](https://github.com/esnme/ultrajson) - यदि आप `UJSONResponse` उपयोग करना चाहते हैं तो आवश्यक।
* [`orjson`](https://github.com/ijl/orjson) - यदि आप `ORJSONResponse` उपयोग करना चाहते हैं तो required।
* [`ujson`](https://github.com/ultrajson/ultrajson) - यदि आप `UJSONResponse` उपयोग करना चाहते हैं तो required।
## लाइसेंस { #license }
यह प्रोजेक्ट MIT लाइसेंस की शर्तों के अंतर्गत लाइसेंस प्राप्त है।
यह project MIT license की शर्तों के अंतर्गत लाइसेंस प्राप्त है।
docs/hi/docs/project-generation.md
+2 -2
View File
@@ -4,13 +4,13 @@ Templates आम तौर पर एक विशिष्ट setup के स
आप शुरू करने के लिए इस template का उपयोग कर सकते हैं, क्योंकि इसमें आपके लिए बहुत सा initial setup, security, database और कुछ API endpoints पहले से तैयार हैं।
GitHub Repository: [Full Stack FastAPI Template](https://github.com/tiangolo/full-stack-fastapi-template)
GitHub Repository: [Full Stack FastAPI Template](https://github.com/fastapi/full-stack-fastapi-template)
## Full Stack FastAPI Template - Technology Stack और Features { #full-stack-fastapi-template-technology-stack-and-features }
- ⚡ Python backend API के लिए [**FastAPI**](https://fastapi.tiangolo.com/hi)।
- 🧰 Python SQL database interactions (ORM) के लिए [SQLModel](https://sqlmodel.tiangolo.com)।
- 🔍 data validation और settings management के लिए [Pydantic](https://docs.pydantic.dev), जिसका उपयोग FastAPI करता है।
- 🔍 data validation और settings management के लिए [Pydantic](https://pydantic.dev/docs/), जिसका उपयोग FastAPI करता है।
- 💾 SQL database के रूप में [PostgreSQL](https://www.postgresql.org)।
- 🚀 frontend के लिए [React](https://react.dev)।
- 💃 TypeScript, hooks, Vite, और modern frontend stack के अन्य parts का उपयोग।
docs/hi/docs/python-types.md
+2 -2
View File
@@ -269,7 +269,7 @@ Types के बिना, इसे हासिल करना लगभग
## Pydantic models { #pydantic-models }
[Pydantic](https://docs.pydantic.dev/) data validation करने के लिए एक Python library है।
[Pydantic](https://pydantic.dev/docs/) data validation करने के लिए एक Python library है।
आप data की "shape" को attributes वाली classes के रूप में declare करते हैं।
@@ -285,7 +285,7 @@ Official Pydantic docs से एक उदाहरण:
/// note | नोट
अधिक जानने के लिए [Pydantic, इसके docs देखें](https://docs.pydantic.dev/)।
अधिक जानने के लिए [Pydantic, इसके docs देखें](https://pydantic.dev/docs/)।
///
docs/hi/docs/tutorial/background-tasks.md
+3 -3
View File
@@ -61,9 +61,9 @@ background task के रूप में चलाने के लिए ए
और फिर *path operation function* पर generate हुआ एक और background task `email` path parameter का उपयोग करके एक message लिखेगा।
## Technical Details { #technical-details }
## तकनीकी विवरण { #technical-details }
class `BackgroundTasks` सीधे [`starlette.background`](https://www.starlette.dev/background/) से आती है।
class `BackgroundTasks` सीधे [`starlette.background`](https://starlette.dev/background/) से आती है।
इसे सीधे FastAPI में import/include किया गया है ताकि आप इसे `fastapi` से import कर सकें और गलती से `starlette.background` से alternative `BackgroundTask` (अंत में `s` के बिना) import करने से बच सकें।
@@ -71,7 +71,7 @@ class `BackgroundTasks` सीधे [`starlette.background`](https://www.starle
FastAPI में अकेले `BackgroundTask` का उपयोग करना अभी भी संभव है, लेकिन आपको अपने code में object बनाना होगा और उसे शामिल करते हुए Starlette `Response` return करना होगा।
आप [Background Tasks के लिए Starlette के official docs](https://www.starlette.dev/background/) में अधिक details देख सकते हैं।
आप [Background Tasks के लिए Starlette के official docs](https://starlette.dev/background/) में अधिक details देख सकते हैं।
## सावधानी { #caveat }
docs/hi/docs/tutorial/bigger-applications.md
+2 -2
View File
@@ -487,7 +487,7 @@ from app.main import app
आप command को path भी pass कर सकते हैं, जैसे:
```console
$ fastapi dev app/main.py
$ uv run fastapi dev app/main.py
```
लेकिन हर बार `fastapi` command call करते समय आपको सही path pass करना याद रखना होगा।
@@ -503,7 +503,7 @@ $ fastapi dev app/main.py
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
docs/hi/docs/tutorial/body-nested-models.md
+1 -1
View File
@@ -96,7 +96,7 @@ Pydantic model के हर attribute का एक type होता है।
`str`, `int`, `float`, आदि जैसे सामान्य singular types के अलावा, आप अधिक complex singular types उपयोग कर सकते हैं जो `str` से inherit करते हैं।
आपके पास मौजूद सभी options देखने के लिए, [Pydantic का Type Overview](https://docs.pydantic.dev/latest/concepts/types/) देखें। अगले chapter में आपको कुछ उदाहरण दिखेंगे।
आपके पास मौजूद सभी options देखने के लिए, [Pydantic का Type Overview](https://pydantic.dev/docs/validation/latest/concepts/types/) देखें। अगले chapter में आपको कुछ उदाहरण दिखेंगे।
उदाहरण के लिए, जैसा कि `Image` model में हमारे पास एक `url` field है, हम इसे `str` के बजाय Pydantic के `HttpUrl` का instance declare कर सकते हैं:
docs/hi/docs/tutorial/body.md
+1 -1
View File
@@ -6,7 +6,7 @@
आपकी API को लगभग हमेशा **response** body भेजनी होती है। लेकिन clients को हर समय **request bodies** भेजने की ज़रूरत नहीं होती, कभी-कभी वे केवल एक path request करते हैं, शायद कुछ query parameters के साथ, लेकिन body नहीं भेजते।
**request** body घोषित करने के लिए, आप [Pydantic](https://docs.pydantic.dev/) models का उनकी पूरी शक्ति और लाभों के साथ उपयोग करते हैं।
**request** body घोषित करने के लिए, आप [Pydantic](https://pydantic.dev/docs/) models का उनकी पूरी शक्ति और लाभों के साथ उपयोग करते हैं।
/// note | नोट
docs/hi/docs/tutorial/debugging.md
+2 -2
View File
@@ -15,7 +15,7 @@
<div class="termy">
```console
$ python myapp.py
$ uv run python myapp.py
```
</div>
@@ -35,7 +35,7 @@ from myapp import app
<div class="termy">
```console
$ python myapp.py
$ uv run python myapp.py
```
</div>
docs/hi/docs/tutorial/extra-data-types.md
+2 -2
View File
@@ -36,7 +36,7 @@
* `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).
* Pydantic इसे "ISO 8601 time diff encoding" के रूप में दर्शाने की अनुमति भी देता है, [अधिक जानकारी के लिए docs देखें](https://pydantic.dev/docs/validation/latest/concepts/serialization/#custom-serializers).
* `frozenset`:
* requests और responses में, इसे `set` जैसा ही माना जाता है:
* requests में, एक list पढ़ी जाएगी, duplicates हटाए जाएँगे और उसे `set` में convert किया जाएगा।
@@ -49,7 +49,7 @@
* `Decimal`:
* Standard Python `Decimal`.
* requests और responses में, इसे `float` जैसा ही handle किया जाएगा।
* आप सभी valid Pydantic data types यहाँ देख सकते हैं: [Pydantic data types](https://docs.pydantic.dev/latest/usage/types/types/).
* आप सभी valid Pydantic data types यहाँ देख सकते हैं: [Pydantic data types](https://pydantic.dev/docs/validation/latest/concepts/types/).
## उदाहरण { #example }
docs/hi/docs/tutorial/extra-models.md
+2 -2
View File
@@ -1,4 +1,4 @@
# Extra Models { #extra-models }
# अतिरिक्त Models { #extra-models }
पिछले उदाहरण को आगे बढ़ाते हुए, एक से अधिक संबंधित model होना आम बात होगी।
@@ -166,7 +166,7 @@ Code duplication कम करना **FastAPI** के core ideas में स
/// note | नोट
[`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions) define करते समय, सबसे specific type को पहले include करें, उसके बाद कम specific type को। नीचे दिए गए उदाहरण में, अधिक specific `PlaneItem`, `Union[PlaneItem, CarItem]` में `CarItem` से पहले आता है।
[`Union`](https://pydantic.dev/docs/validation/latest/concepts/unions/) define करते समय, सबसे specific type को पहले include करें, उसके बाद कम specific type को। नीचे दिए गए उदाहरण में, अधिक specific `PlaneItem`, `Union[PlaneItem, CarItem]` में `CarItem` से पहले आता है।
///
docs/hi/docs/tutorial/first-steps.md
+12 -6
View File
@@ -6,12 +6,18 @@
इसे `main.py` नाम की file में copy करें।
/// 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 से।
///
live server चलाएँ:
<div class="termy">
```console
$ <font color="#4E9A06">fastapi</font> dev
$ <font color="#4E9A06">uv run fastapi</font> dev
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server 🚀
@@ -78,7 +84,7 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
और अब, [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) पर जाएँ।
आपको वैकल्पिक automatic documentation दिखेगी ([ReDoc](https://github.com/Rebilly/ReDoc) द्वारा प्रदान की गई):
आपको वैकल्पिक automatic documentation दिखेगी ([ReDoc](https://github.com/Redocly/redoc) द्वारा प्रदान की गई):
![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
@@ -185,13 +191,13 @@ from backend.main import app
आप `fastapi dev` command को file path भी pass कर सकते हैं, और यह उपयोग करने के लिए FastAPI app object का अनुमान लगा लेगा:
```console
$ fastapi dev main.py
$ uv run fastapi dev main.py
```
या, आप `fastapi dev` command को `--entrypoint` option भी pass कर सकते हैं:
```console
$ fastapi dev --entrypoint main:app
$ uv run fastapi dev --entrypoint main:app
```
लेकिन हर बार `fastapi` command call करते समय आपको सही path\entrypoint pass करना याद रखना होगा।
@@ -205,7 +211,7 @@ $ fastapi dev --entrypoint main:app
<div class="termy">
```console
$ fastapi deploy
$ uv run fastapi deploy
Deploying to FastAPI Cloud...
@@ -232,7 +238,7 @@ CLI आपकी FastAPI application को अपने आप detect करे
`FastAPI` एक class है जो सीधे `Starlette` से inherit करती है।
आप `FastAPI` के साथ सारी [Starlette](https://www.starlette.dev/) functionality भी उपयोग कर सकते हैं।
आप `FastAPI` के साथ सारी [Starlette](https://starlette.dev/) functionality भी उपयोग कर सकते हैं।
///
docs/hi/docs/tutorial/frontend.md
+9 -3
View File
@@ -52,7 +52,7 @@ npm run build
{* ../../docs_src/frontend/tutorial002_py310.py hl[5] *}
**FastAPI** इस fallback का उपयोग केवल उन `GET` और `HEAD` requests के लिए करता है जो browser navigation जैसी दिखती हैं। JavaScript, CSS, और images जैसी missing files अभी भी `404` लौटाती हैं।
**FastAPI** इस fallback का उपयोग केवल उन `GET` और `HEAD` requests के लिए करता है जो स्पष्ट रूप से `Accept: text/html` या `Accept: application/xhtml+xml` के साथ HTML accept करती हैं, जैसा browser navigation requests सामान्यतः करती हैं। JavaScript, CSS, और images जैसी missing files अभी भी `404` लौटाती हैं।
अन्य methods वाली requests, जैसे `POST` या `PUT`, उन paths पर जो केवल frontend fallback से match करते हैं, वे भी `404` लौटाती हैं। नियमित **FastAPI** *path operations* की priority अभी भी frontend routes से अधिक होती है।
@@ -106,9 +106,13 @@ Default रूप से, `app.frontend()` `fallback="auto"` का उपयो
## Directory जाँचें { #check-directory }
Default रूप से, `app.frontend()` app बनाते समय जाँचता है कि directory मौजूद है।
Default रूप से, `app.frontend()` `check_dir="auto"` का उपयोग करता है।
यह configuration errors को जल्दी पकड़ने में मदद करता है। उदाहरण के लिए, अगर frontend build output directory missing है, तो **FastAPI** startup पर error raise करेगा।
जब `FASTAPI_ENV` environment variable को `development` पर set किया जाता है, तो अगर frontend build output directory missing है तो **FastAPI** केवल एक warning दिखाता है। [`fastapi dev` command](https://github.com/fastapi/fastapi-cli#fastapi-dev) आपके लिए यह environment variable set करता है अगर यह पहले से set नहीं है। यह आपको development के दौरान frontend को build या start करने से पहले backend start करने देता है।
किसी भी अन्य environment में, app बनाए जाने पर **FastAPI** error raise करता है। यह frontend files के बिना app deploy करने से पहले configuration errors को जल्दी पकड़ने में मदद करता है।
आप app बनाए जाने पर हमेशा directory की जाँच करने के लिए `check_dir=True` भी set कर सकते हैं।
अगर आपकी frontend files बाद में बनाई जाती हैं, उदाहरण के लिए app object बनने के बाद किसी अलग build step द्वारा, तो `check_dir=False` set करें:
@@ -132,6 +136,8 @@ Frontend responses सामान्य **FastAPI** application के अं
App से, `APIRouter` से, और `include_router()` से dependencies भी frontend responses पर लागू होती हैं। यह cookie authentication या इसी तरह से frontend को protect करने के लिए उपयोगी हो सकता है।
Dependencies response headers को modify भी कर सकती हैं और background tasks add कर सकती हैं, जैसे सामान्य *path operations* के साथ।
## केवल Static Build Output { #static-build-output-only }
`app.frontend()` आपके frontend build द्वारा पहले से generate की गई files serve करता है।
docs/hi/docs/tutorial/handling-errors.md
+3 -3
View File
@@ -81,7 +81,7 @@ Client को errors वाली HTTP responses return करने के ल
## custom exception handlers install करें { #install-custom-exception-handlers }
आप [Starlette से वही exception utilities](https://www.starlette.dev/exceptions/) के साथ custom exception handlers जोड़ सकते हैं।
आप [Starlette से वही exception utilities](https://starlette.dev/exceptions/) के साथ custom exception handlers जोड़ सकते हैं।
मान लीजिए आपके पास एक custom exception `UnicornException` है जिसे आप (या कोई library जिसका आप उपयोग करते हैं) `raise` कर सकते हैं।
@@ -101,7 +101,7 @@ Client को errors वाली HTTP responses return करने के ल
{"message": "Oops! yolo did something. There goes a rainbow..."}
```
/// note | Technical Details
/// note | तकनीकी विवरण
आप `from starlette.requests import Request` और `from starlette.responses import JSONResponse` का भी उपयोग कर सकते हैं।
@@ -161,7 +161,7 @@ Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to pa
{* ../../docs_src/handling_errors/tutorial004_py310.py hl[3:4,9:11,25] *}
/// note | Technical Details
/// note | तकनीकी विवरण
आप `from starlette.responses import PlainTextResponse` का भी उपयोग कर सकते हैं।
docs/hi/docs/tutorial/index.md
+55 -15
View File
@@ -10,12 +10,12 @@
सभी code blocks को copy करके सीधे उपयोग किया जा सकता है (वे वास्तव में tested Python files हैं)।
किसी भी example को चलाने के लिए, code को `main.py` file में copy करें, और `fastapi dev` शुरू करें:
किसी भी example को चलाने के लिए, code को `main.py` file में copy करें, और `uv run` के साथ `fastapi dev` शुरू करें:
<div class="termy">
```console
$ <font color="#4E9A06">fastapi</font> dev
$ <font color="#4E9A06">uv run fastapi</font> dev
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server 🚀
@@ -60,35 +60,75 @@ $ <font color="#4E9A06">fastapi</font> dev
## FastAPI install करें { #install-fastapi }
पहला step FastAPI install करना है।
पहला step अपने project को set up करना और FastAPI जोड़ना है।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर **FastAPI install करें**:
[`uv`](https://docs.astral.sh/uv/getting-started/installation/) install करें, फिर एक project बनाएँ और FastAPI जोड़ें:
<div class="termy">
```console
$ pip install "fastapi[standard]"
$ uv init awesome-project --bare
$ cd awesome-project
$ uv add "fastapi[standard]"
---> 100%
```
</div>
`uv add` project की virtual environment को `.venv` में बनाता है, FastAPI को `pyproject.toml` में जोड़ता है, और `uv.lock` बनाता है ताकि वही package versions बाद में install किए जा सकें।
/// details | ये commands क्या करते हैं
* `uv init`: एक नया Python project बनाएँ।
* `awesome-project`: इस नाम के साथ एक नई directory में project बनाएँ।
* `--bare`: sample `main.py`, `README.md`, या दूसरी files generate किए बिना, केवल minimal `pyproject.toml` file बनाएँ। आप इस tutorial के अगले steps में application files खुद बनाएँगे।
फिर FastAPI जोड़ने से पहले `cd awesome-project` नई project directory में जाता है।
`uv` आपके system पर पहले से install compatible Python version का उपयोग करेगा, या ज़रूरत होने पर एक download करेगा।
जब आप `uv add` चलाते हैं, तो यह FastAPI और उन सभी packages के compatible versions चुनता है जिन पर FastAPI depend करता है। यह exact versions को `uv.lock` में record करता है, जिससे बाद में किसी दूसरे computer पर या application deploy करते समय वही package versions install करना संभव होता है।
इस file को बनाना या update करना [project dependencies को **locking** करना](https://docs.astral.sh/uv/concepts/projects/sync/) कहलाता है। जब आप package जोड़ते हैं तो `uv` यह automatically करता है।
///
/// details | FastAPI installation options
जब आप `uv add "fastapi[standard]"` के साथ install करते हैं, तो यह कुछ default optional standard dependencies के साथ आता है, जिनमें `fastapi-cloud-cli` शामिल है, जो आपको [FastAPI Cloud](https://fastapicloud.com) पर deploy करने देता है।
अगर आप वे optional dependencies नहीं चाहते, तो इसके बजाय आप `uv add fastapi` install कर सकते हैं।
अगर आप standard dependencies install करना चाहते हैं लेकिन `fastapi-cloud-cli` के बिना, तो आप `uv add "fastapi[standard-no-fastapi-cloud-cli]"` के साथ install कर सकते हैं।
///
/// details | इसके बजाय `pip` का उपयोग करना
अगर आप virtual environment और packages को manually manage करना पसंद करते हैं, तो एक virtual environment बनाएँ और activate करें और फिर `pip install "fastapi[standard]"` के साथ FastAPI install करें।
विस्तृत steps के लिए [Virtual Environments guide](https://tiangolo.com/guides/virtual-environments/) पढ़ें।
///
## AI Agent Skills { #ai-agent-skills }
FastAPI में AI coding agents के लिए एक official skill शामिल है। यह package के साथ bundled है, इसलिए इसका guidance आपके project में install FastAPI के version के साथ aligned रहता है और जब आप FastAPI update करते हैं तो update होता है।
अपने project में FastAPI install करने के बाद, आप <a href="https://library-skills.io">Library Skills</a> के साथ skill install कर सकते हैं:
```bash
uvx library-skills
```
/// 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 कर सकते हैं।
`uvx` `uv tool run` के लिए एक alias है। यह Library Skills को एक temporary, isolated environment में चलाता है जबकि Library Skills आपके project में install packages को scan करता है।
///
/// 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 से।
///
यह skill Codex, Claude Code, Cursor, GitHub Copilot, Gemini CLI, Pi, OpenCode, और अधिकतर अन्य coding agents के साथ compatible है। Claude Code के लिए, जब पूछा जाए कि skill कहाँ install करना है तो `.claude/skills` चुनें।
## उन्नत उपयोगकर्ता गाइड { #advanced-user-guide }
docs/hi/docs/tutorial/middleware.md
+1 -1
View File
@@ -37,7 +37,7 @@ middleware function को मिलता है:
ध्यान रखें कि 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 है।
लेकिन अगर आपके पास custom headers हैं जिन्हें आप browser में client को दिखाना चाहते हैं, तो आपको उन्हें अपने CORS configurations ([CORS (Cross-Origin Resource Sharing)](cors.md)) में `expose_headers` parameter का उपयोग करके जोड़ना होगा, जैसा कि [Starlette के CORS docs](https://starlette.dev/middleware/#corsmiddleware) में documented है।
///
docs/hi/docs/tutorial/path-params.md
+2 -2
View File
@@ -92,7 +92,7 @@ path parameter `item_id` की value आपके function को argument `ite
## 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 हैं।
और क्योंकि generate किया गया schema [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/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 कर सकते हैं:
@@ -102,7 +102,7 @@ path parameter `item_id` की value आपके function को argument `ite
## Pydantic { #pydantic }
सारा data validation अंदरूनी तौर पर [Pydantic](https://docs.pydantic.dev/) द्वारा किया जाता है, इसलिए आपको इसके सभी लाभ मिलते हैं। और आप जानते हैं कि आप अच्छे हाथों में हैं।
सारा data validation अंदरूनी तौर पर [Pydantic](https://pydantic.dev/docs/) द्वारा किया जाता है, इसलिए आपको इसके सभी लाभ मिलते हैं। और आप जानते हैं कि आप अच्छे हाथों में हैं।
आप `str`, `float`, `bool` और कई अन्य जटिल data types के साथ वही type declarations इस्तेमाल कर सकते हैं।
docs/hi/docs/tutorial/query-params-str-validations.md
+4 -4
View File
@@ -348,7 +348,7 @@ http://127.0.0.1:8000/items/?item-query=foobaritems
अब मान लीजिए कि आपको यह parameter अब पसंद नहीं है।
आपको इसे कुछ समय के लिए वहीं छोड़ना होगा क्योंकि clients इसे use कर रहे हैं, लेकिन आप चाहते हैं कि docs इसे स्पष्ट रूप से <dfn title="obsolete, इसका उपयोग न करने की recommendation है">deprecated</dfn> के रूप में दिखाएँ।
आपको इसे कुछ समय के लिए वहीं छोड़ना होगा क्योंकि clients इसे use कर रहे हैं, लेकिन आप चाहते हैं कि docs इसे स्पष्ट रूप से <dfn title="अप्रचलित, इसका उपयोग न करने की recommendation है">deprecated</dfn> के रूप में दिखाएँ।
फिर parameter `deprecated=True` को `Query` में pass करें:
@@ -370,15 +370,15 @@ generated OpenAPI schema से query parameter exclude करने के ल
ऐसे cases में, आप एक **custom validator function** use कर सकते हैं जो normal validation के बाद apply होता है (जैसे value के `str` होने की validation के बाद)।
आप इसे `Annotated` के अंदर [Pydantic के `AfterValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) का उपयोग करके हासिल कर सकते हैं।
आप इसे `Annotated` के अंदर [Pydantic के `AfterValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-after-validator) का उपयोग करके हासिल कर सकते हैं।
/// tip | टिप
Pydantic में [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) और अन्य भी हैं। 🤓
Pydantic में [`BeforeValidator`](https://pydantic.dev/docs/validation/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-` से:
उदाहरण के लिए, यह custom validator check करता है कि item ID किसी <abbr title="International Standard Book Number - अंतर्राष्ट्रीय standard पुस्तक संख्या">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] *}
docs/hi/docs/tutorial/request-files.md
+2 -2
View File
@@ -6,10 +6,10 @@
अपलोड की गई files प्राप्त करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
इसे अपने project में जोड़ें:
```console
$ pip install python-multipart
$ uv add python-multipart
```
ऐसा इसलिए है क्योंकि अपलोड की गई files "form data" के रूप में भेजी जाती हैं।
docs/hi/docs/tutorial/request-form-models.md
+2 -2
View File
@@ -6,10 +6,10 @@
forms का उपयोग करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
इसे अपने project में जोड़ें:
```console
$ pip install python-multipart
$ uv add python-multipart
```
///
docs/hi/docs/tutorial/request-forms-and-files.md
+2 -2
View File
@@ -6,10 +6,10 @@
अपलोड की गई files और/या form data प्राप्त करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर इसे install करें, उदाहरण के लिए:
इसे अपने project में जोड़ें:
```console
$ pip install python-multipart
$ uv add python-multipart
```
///
docs/hi/docs/tutorial/request-forms.md
+2 -2
View File
@@ -6,10 +6,10 @@
forms का उपयोग करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
इसे अपने project में जोड़ें:
```console
$ pip install python-multipart
$ uv add python-multipart
```
///
docs/hi/docs/tutorial/response-model.md
+4 -4
View File
@@ -76,16 +76,16 @@ FastAPI इस `response_model` का उपयोग सभी data documentat
`EmailStr` का उपयोग करने के लिए, पहले [`email-validator`](https://github.com/JoshData/python-email-validator) install करें।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
इसे अपने project में जोड़ें:
```console
$ pip install email-validator
$ uv add email-validator
```
या इसके साथ:
```console
$ pip install "pydantic[email]"
$ uv add "pydantic[email]"
```
///
@@ -258,7 +258,7 @@ FastAPI internally Pydantic के साथ कई चीज़ें करत
* `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) में बताया गया है।
जैसा कि `exclude_defaults` और `exclude_none` के लिए [Pydantic docs](https://pydantic.dev/docs/validation/latest/concepts/serialization/#excluding-and-including-fields-based-on-their-value) में बताया गया है।
///
docs/hi/docs/tutorial/schema-extra-example.md
+2 -2
View File
@@ -12,7 +12,7 @@
वह अतिरिक्त जानकारी उस model के output **JSON Schema** में जैसी है वैसी ही जोड़ी जाएगी, और API docs में उपयोग की जाएगी।
आप `model_config` attribute का उपयोग कर सकते हैं, जो एक `dict` लेता है, जैसा कि [Pydantic के docs: Configuration](https://docs.pydantic.dev/latest/api/config/) में बताया गया है।
आप `model_config` attribute का उपयोग कर सकते हैं, जो एक `dict` लेता है, जैसा कि [Pydantic के docs: Configuration](https://pydantic.dev/docs/validation/latest/api/pydantic/config/) में बताया गया है।
आप `"json_schema_extra"` को एक `dict` के साथ set कर सकते हैं जिसमें कोई भी अतिरिक्त data हो जिसे आप generated JSON Schema में दिखाना चाहते हैं, जिसमें `examples` भी शामिल हैं।
@@ -169,7 +169,7 @@ OpenAPI ने specification के अन्य हिस्सों में
और अब यह नया `examples` field पुराने single (और custom) `example` field पर precedence लेता है, जो अब deprecated है।
JSON Schema में यह नया `examples` field OpenAPI में अन्य जगहों (ऊपर वर्णित) की तरह अतिरिक्त metadata वाला dict नहीं है, यह **सिर्फ एक `list`** है।
JSON Schema में यह नया `examples` field OpenAPI में अन्य जगहों (ऊपर वर्णित) की तरह अतिरिक्त metadata वाला dict नहीं है, यह **सिर्फ examples की एक `list`** है।
/// note | नोट
docs/hi/docs/tutorial/security/first-steps.md
+5 -5
View File
@@ -26,14 +26,14 @@
/// note | नोट
[`python-multipart`](https://github.com/Kludex/python-multipart) package **FastAPI** के साथ अपने-आप install हो जाता है जब आप `pip install "fastapi[standard]"` command चलाते हैं।
[`python-multipart`](https://github.com/Kludex/python-multipart) package **FastAPI** के साथ अपने-आप install हो जाता है जब आप `uv add "fastapi[standard]"` command चलाते हैं।
हालाँकि, अगर आप `pip install fastapi` command का उपयोग करते हैं, तो `python-multipart` package default रूप से शामिल नहीं होता।
हालाँकि, अगर आप `uv add fastapi` command का उपयोग करते हैं, तो `python-multipart` package default रूप से शामिल नहीं होता।
इसे manually install करने के लिए, सुनिश्चित करें कि आप एक [virtual environment](../../virtual-environments.md) बनाएँ, उसे activate करें, और फिर इसे इस तरह install करें:
इसे manually install करने के लिए, इसे अपने project में इस तरह जोड़ें:
```console
$ pip install python-multipart
$ uv add python-multipart
```
ऐसा इसलिए है क्योंकि **OAuth2**, `username` और `password` भेजने के लिए "form data" का उपयोग करता है।
@@ -45,7 +45,7 @@ $ pip install python-multipart
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
docs/hi/docs/tutorial/security/oauth2-jwt.md
+4 -4
View File
@@ -30,12 +30,12 @@ eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4
Python में JWT tokens generate और verify करने के लिए हमें `PyJWT` install करना होगा।
सुनिश्चित करें कि आप एक [virtual environment](../../virtual-environments.md) बनाएँ, उसे activate करें, और फिर `pyjwt` install करें:
अपने project में `pyjwt` जोड़ें:
<div class="termy">
```console
$ pip install pyjwt
$ uv add pyjwt
---> 100%
```
@@ -72,12 +72,12 @@ pwdlib password hashes संभालने के लिए एक शान
Recommended algorithm "Argon2" है।
सुनिश्चित करें कि आप एक [virtual environment](../../virtual-environments.md) बनाएँ, उसे activate करें, और फिर Argon2 के साथ pwdlib install करें:
अपने project में Argon2 के साथ `pwdlib` जोड़ें:
<div class="termy">
```console
$ pip install "pwdlib[argon2]"
$ uv add "pwdlib[argon2]"
---> 100%
```
docs/hi/docs/tutorial/sql-databases.md
+4 -4
View File
@@ -34,12 +34,12 @@
## `SQLModel` install करें { #install-sqlmodel }
सबसे पहले, सुनिश्चित करें कि आप अपना [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर `sqlmodel` install करें:
`sqlmodel` को अपने project में जोड़ें:
<div class="termy">
```console
$ pip install sqlmodel
$ uv add sqlmodel
---> 100%
```
@@ -152,7 +152,7 @@ SQLModel में Alembic को wrap करने वाली migration utili
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -337,7 +337,7 @@ hero को **delete करना** लगभग पहले जैसा ह
<div class="termy">
```console
$ fastapi dev
$ uv run fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
docs/hi/docs/tutorial/static-files.md
+1 -1
View File
@@ -45,4 +45,4 @@
## अधिक जानकारी { #more-info }
अधिक विवरण और options के लिए [Static Files के बारे में Starlette की docs](https://www.starlette.dev/staticfiles/) देखें।
अधिक विवरण और options के लिए [Static Files के बारे में Starlette की docs](https://starlette.dev/staticfiles/) देखें।
docs/hi/docs/tutorial/testing.md
+6 -6
View File
@@ -1,6 +1,6 @@
# Testing { #testing }
[Starlette](https://www.starlette.dev/testclient/) की बदौलत, **FastAPI** applications की testing आसान और आनंददायक है।
[Starlette](https://starlette.dev/testclient/) की बदौलत, **FastAPI** applications की testing आसान और आनंददायक है।
यह [HTTPX](https://www.python-httpx.org) पर आधारित है, जो बदले में Requests के आधार पर design किया गया है, इसलिए यह बहुत परिचित और intuitive है।
@@ -12,10 +12,10 @@
`TestClient` का उपयोग करने के लिए, पहले [`httpx`](https://www.python-httpx.org) install करें।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
इसे अपने project में जोड़ें:
```console
$ pip install httpx
$ uv add httpx
```
///
@@ -156,12 +156,12 @@ backend को data कैसे pass करें (`httpx` या `TestClient`
उसके बाद, आपको बस `pytest` install करना है।
सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
इसे अपने project में जोड़ें:
<div class="termy">
```console
$ pip install pytest
$ uv add pytest
---> 100%
```
@@ -175,7 +175,7 @@ Tests चलाएँ:
<div class="termy">
```console
$ pytest
$ uv run pytest
================ test session starts ================
platform linux -- Python 3.6.9, pytest-5.3.5, py-1.8.1, pluggy-0.13.1
docs/hi/docs/virtual-environments.md
+10 -839
View File
@@ -1,864 +1,35 @@
# Virtual Environments { #virtual-environments }
जब आप Python projects पर काम करते हैं, तो संभवतः आपको हर project के लिए install किए जाने वाले packages को अलग रखने के लिए एक **virtual environment** (या कोई समान तरीका) इस्तेमाल करना चाहिए।
जब आप Python projects पर काम करते हैं, तो आपको हर project के लिए install किए गए packages को अलग रखने के लिए एक **virtual environment** का उपयोग करना चाहिए।
/// note | नोट
अगर आप पहले से virtual environments के बारे में जानते हैं, उन्हें कैसे बनाना और इस्तेमाल करना है जानते हैं, तो आप इस section को छोड़ना चाह सकते हैं। 🤓
///
/// tip | सुझाव
एक **virtual environment**, एक **environment variable** से अलग होता है।
एक **environment variable** system में एक variable होता है जिसे programs इस्तेमाल कर सकते हैं।
एक **virtual environment** एक directory होती है जिसमें कुछ files होती हैं।
///
/// note | नोट
यह पेज आपको **virtual environments** का उपयोग करना और वे कैसे काम करते हैं, सिखाएगा।
अगर आप अपने लिए **सब कुछ manage करने वाला tool** अपनाने के लिए तैयार हैं (जिसमें Python install करना भी शामिल है), तो [uv](https://github.com/astral-sh/uv) आज़माएँ।
///
FastAPI projects के लिए, मैं project, उसकी dependencies, और उसके virtual environment को manage करने के लिए [uv](https://docs.astral.sh/uv/) उपयोग करने की सलाह देता हूँ।
## Project बनाएँ { #create-a-project }
सबसे पहले, अपने project के लिए एक directory बनाएँ।
मैं सामान्यतः अपनी home/user directory के अंदर `code` नाम की एक directory बनाता हूँ।
और उसके अंदर हर project के लिए एक directory बनाता हूँ।
[official installation guide](https://docs.astral.sh/uv/getting-started/installation/) का उपयोग करके `uv` install करें, और फिर एक project बनाएँ:
<div class="termy">
```console
// home directory में जाएँ
$ cd
// अपने सभी code projects के लिए एक directory बनाएँ
$ mkdir code
// उस code directory में जाएँ
$ cd code
// इस project के लिए एक directory बनाएँ
$ mkdir awesome-project
// उस project directory में जाएँ
$ uv init awesome-project --bare
$ cd awesome-project
$ uv add "fastapi[standard]"
```
</div>
## Virtual Environment बनाएँ { #create-a-virtual-environment }
`uv` project के लिए virtual environment automatically बनाता है। आपको खुद कोई बनाने या activate करने की ज़रूरत नहीं है।
जब आप किसी Python project पर **पहली बार** काम शुरू करते हैं, तो एक virtual environment **<dfn title="दूसरे विकल्प भी हैं, यह एक सरल guideline है">अपने project के अंदर</dfn>** बनाएँ।
/// tip | सुझाव
आपको यह **हर project के लिए केवल एक बार** करना होता है, हर बार काम करते समय नहीं।
///
//// tab | `venv`
Virtual environment बनाने के लिए, आप Python के साथ आने वाले `venv` module का उपयोग कर सकते हैं।
Project environment के अंदर commands `uv run` से चलाएँ, उदाहरण के लिए:
<div class="termy">
```console
$ python -m venv .venv
$ uv run fastapi dev
```
</div>
/// details | उस command का क्या अर्थ है
## और जानें { #learn-more }
* `python`: `python` नाम के program का उपयोग करें
* `-m`: किसी module को script की तरह call करें, अगला हम उसे बताएँगे कि कौन-सा module
* `venv`: `venv` नाम के module का उपयोग करें जो सामान्यतः Python के साथ install आता है
* `.venv`: नई directory `.venv` में virtual environment बनाएँ
///
////
//// tab | `uv`
अगर आपके पास [`uv`](https://github.com/astral-sh/uv) install है, तो आप इसका उपयोग virtual environment बनाने के लिए कर सकते हैं।
<div class="termy">
```console
$ uv venv
```
</div>
/// tip | सुझाव
Default रूप से, `uv` `.venv` नाम की directory में virtual environment बनाएगा।
लेकिन आप directory नाम के साथ एक अतिरिक्त argument देकर इसे customize कर सकते हैं।
///
////
वह command `.venv` नाम की directory में एक नया virtual environment बनाता है।
/// details | `.venv` या कोई दूसरा नाम
आप virtual environment को किसी दूसरी directory में बना सकते हैं, लेकिन इसे `.venv` कहने की एक convention है।
///
## Virtual Environment activate करें { #activate-the-virtual-environment }
नए virtual environment को activate करें ताकि आप जो भी Python command चलाएँ या जो package install करें, वह इसका उपयोग करे।
/// tip | सुझाव
Project पर काम करने के लिए **हर बार** जब आप एक **नया terminal session** शुरू करें, तो यह करें।
///
//// tab | Linux, macOS
<div class="termy">
```console
$ source .venv/bin/activate
```
</div>
////
//// tab | Windows PowerShell
<div class="termy">
```console
$ .venv\Scripts\Activate.ps1
```
</div>
////
//// tab | Windows Bash
या अगर आप Windows के लिए Bash का उपयोग करते हैं (जैसे [Git Bash](https://gitforwindows.org/)):
<div class="termy">
```console
$ source .venv/Scripts/activate
```
</div>
////
/// tip | सुझाव
हर बार जब आप उस environment में कोई **नया package** install करें, तो environment को फिर से **activate** करें।
यह सुनिश्चित करता है कि अगर आप उस package द्वारा install किया गया कोई **terminal (<abbr title="command line interface - कमांड लाइन इंटरफ़ेस">CLI</abbr>) program** इस्तेमाल करते हैं, तो आप अपने virtual environment वाला ही उपयोग करें, कोई और नहीं जो global रूप से install हो सकता है, शायद आपकी ज़रूरत से अलग version के साथ।
///
## जाँचें कि Virtual Environment Active है { #check-the-virtual-environment-is-active }
जाँचें कि virtual environment active है (पिछली command ने काम किया)।
/// tip | सुझाव
यह **वैकल्पिक** है, लेकिन यह **जाँचने** का एक अच्छा तरीका है कि सब कुछ अपेक्षा के अनुसार काम कर रहा है और आप वही virtual environment इस्तेमाल कर रहे हैं जिसका आपने इरादा किया था।
///
//// tab | Linux, macOS, Windows Bash
<div class="termy">
```console
$ which python
/home/user/code/awesome-project/.venv/bin/python
```
</div>
अगर यह `.venv/bin/python` पर `python` binary दिखाता है, आपके project के अंदर (इस मामले में `awesome-project`), तो यह काम कर गया। 🎉
////
//// tab | Windows PowerShell
<div class="termy">
```console
$ Get-Command python
C:\Users\user\code\awesome-project\.venv\Scripts\python
```
</div>
अगर यह `.venv\Scripts\python` पर `python` binary दिखाता है, आपके project के अंदर (इस मामले में `awesome-project`), तो यह काम कर गया। 🎉
////
## `pip` Upgrade करें { #upgrade-pip }
/// tip | सुझाव
अगर आप [`uv`](https://github.com/astral-sh/uv) का उपयोग करते हैं, तो आप चीजें install करने के लिए `pip` की बजाय उसी का उपयोग करेंगे, इसलिए आपको `pip` upgrade करने की ज़रूरत नहीं है। 😎
///
अगर आप packages install करने के लिए `pip` का उपयोग कर रहे हैं (यह Python के साथ default रूप से आता है), तो आपको इसे latest version में **upgrade** करना चाहिए।
किसी package को install करते समय कई अजीब errors केवल पहले `pip` upgrade करने से हल हो जाते हैं।
/// tip | सुझाव
आप सामान्यतः यह **एक बार** करेंगे, virtual environment बनाने के ठीक बाद।
///
सुनिश्चित करें कि virtual environment active है (ऊपर वाली command से) और फिर चलाएँ:
<div class="termy">
```console
$ python -m pip install --upgrade pip
---> 100%
```
</div>
/// tip | सुझाव
कभी-कभी, pip upgrade करने की कोशिश करते समय आपको **`No module named pip`** error मिल सकता है।
अगर ऐसा होता है, तो नीचे दी गई command का उपयोग करके pip install और upgrade करें:
<div class="termy">
```console
$ python -m ensurepip --upgrade
---> 100%
```
</div>
यह command pip को install करेगी अगर वह पहले से install नहीं है और यह भी सुनिश्चित करेगी कि install किया गया pip का version कम से कम `ensurepip` में उपलब्ध version जितना नया हो।
///
## `.gitignore` जोड़ें { #add-gitignore }
अगर आप **Git** का उपयोग कर रहे हैं (आपको करना चाहिए), तो अपनी `.venv` की हर चीज़ को Git से exclude करने के लिए एक `.gitignore` file जोड़ें।
/// tip | सुझाव
अगर आपने virtual environment बनाने के लिए [`uv`](https://github.com/astral-sh/uv) का उपयोग किया है, तो यह आपके लिए पहले ही कर चुका है, आप यह step छोड़ सकते हैं। 😎
///
/// tip | सुझाव
यह **एक बार** करें, virtual environment बनाने के ठीक बाद।
///
<div class="termy">
```console
$ echo "*" > .venv/.gitignore
```
</div>
/// details | उस command का क्या अर्थ है
* `echo "*"`: terminal में text `*` को "print" करेगा (अगला हिस्सा इसे थोड़ा बदल देता है)
* `>`: `>` के बाईं ओर वाली command द्वारा terminal में print की गई कोई भी चीज़ print नहीं होनी चाहिए, बल्कि `>` के दाईं ओर वाली file में लिखी जानी चाहिए
* `.gitignore`: उस file का नाम जहाँ text लिखा जाना चाहिए
और Git के लिए `*` का मतलब "सब कुछ" होता है। इसलिए, यह `.venv` directory में सब कुछ ignore करेगा।
वह command `.gitignore` file बनाएगी, इस content के साथ:
```gitignore
*
```
///
## Packages install करें { #install-packages }
Environment activate करने के बाद, आप उसमें packages install कर सकते हैं।
/// tip | सुझाव
जब आप अपने project के लिए required packages install या upgrade कर रहे हों, तो यह **एक बार** करें।
अगर आपको किसी version को upgrade करना हो या कोई नया package जोड़ना हो, तो आप **यह फिर से करेंगे**।
///
### सीधे Packages install करें { #install-packages-directly }
अगर आप जल्दी में हैं और अपने project की package requirements declare करने के लिए कोई file इस्तेमाल नहीं करना चाहते, तो आप उन्हें सीधे install कर सकते हैं।
/// tip | सुझाव
आपके program को जिन packages और versions की ज़रूरत है, उन्हें एक file में रखना (बहुत) अच्छा विचार है (उदाहरण के लिए `requirements.txt` या `pyproject.toml`)।
///
//// tab | `pip`
<div class="termy">
```console
$ pip install "fastapi[standard]"
---> 100%
```
</div>
////
//// tab | `uv`
अगर आपके पास [`uv`](https://github.com/astral-sh/uv) है:
<div class="termy">
```console
$ uv pip install "fastapi[standard]"
---> 100%
```
</div>
////
### `requirements.txt` से install करें { #install-from-requirements-txt }
अगर आपके पास `requirements.txt` है, तो अब आप इसके packages install करने के लिए इसका उपयोग कर सकते हैं।
//// tab | `pip`
<div class="termy">
```console
$ pip install -r requirements.txt
---> 100%
```
</div>
////
//// tab | `uv`
अगर आपके पास [`uv`](https://github.com/astral-sh/uv) है:
<div class="termy">
```console
$ uv pip install -r requirements.txt
---> 100%
```
</div>
////
/// details | `requirements.txt`
कुछ packages वाला `requirements.txt` ऐसा दिख सकता है:
```requirements.txt
fastapi[standard]==0.113.0
pydantic==2.8.0
```
///
## अपना Program चलाएँ { #run-your-program }
Virtual environment activate करने के बाद, आप अपना program चला सकते हैं, और यह आपके virtual environment के अंदर मौजूद Python का उपयोग करेगा, उन packages के साथ जिन्हें आपने वहाँ install किया है।
<div class="termy">
```console
$ python main.py
Hello World
```
</div>
## अपना Editor Configure करें { #configure-your-editor }
आप शायद एक editor का उपयोग करेंगे, सुनिश्चित करें कि आप इसे उसी virtual environment का उपयोग करने के लिए configure करें जिसे आपने बनाया है (यह शायद इसे autodetect कर लेगा), ताकि आपको autocompletion और inline errors मिल सकें।
उदाहरण के लिए:
* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment)
* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html)
/// tip | सुझाव
आपको सामान्यतः यह केवल **एक बार** करना होता है, जब आप virtual environment बनाते हैं।
///
## Virtual Environment deactivate करें { #deactivate-the-virtual-environment }
जब आप अपने project पर काम कर लें, तो आप virtual environment को **deactivate** कर सकते हैं।
<div class="termy">
```console
$ deactivate
```
</div>
इस तरह, जब आप `python` चलाएँगे, तो यह वहाँ install packages वाले उस virtual environment से इसे चलाने की कोशिश नहीं करेगा।
## काम करने के लिए तैयार { #ready-to-work }
अब आप अपने project पर काम शुरू करने के लिए तैयार हैं।
/// tip | सुझाव
क्या आप समझना चाहते हैं कि ऊपर की सारी चीज़ें क्या हैं?
आगे पढ़ते रहें। 👇🤓
///
## Virtual Environments क्यों { #why-virtual-environments }
FastAPI के साथ काम करने के लिए आपको [Python](https://www.python.org/) install करना होगा।
उसके बाद, आपको FastAPI और कोई भी अन्य **packages** जिन्हें आप इस्तेमाल करना चाहते हैं, **install** करने होंगे।
Packages install करने के लिए आप सामान्यतः Python के साथ आने वाली `pip` command (या समान alternatives) का उपयोग करेंगे।
फिर भी, अगर आप सीधे `pip` का उपयोग करते हैं, तो packages आपके **global Python environment** (Python की global installation) में install हो जाएँगे।
### समस्या { #the-problem }
तो, global Python environment में packages install करने में समस्या क्या है?
किसी समय, आप शायद कई अलग-अलग programs लिखेंगे जो **अलग-अलग packages** पर निर्भर करते हैं। और जिन projects पर आप काम करेंगे उनमें से कुछ उसी package के **अलग-अलग versions** पर निर्भर होंगे। 😱
उदाहरण के लिए, आप `philosophers-stone` नाम का एक project बना सकते हैं, यह program **`harry`, version `1`** नाम के किसी दूसरे package पर निर्भर करता है। इसलिए, आपको `harry` install करना होगा।
```mermaid
flowchart LR
stone(philosophers-stone) -->|requires| harry-1[harry v1]
```
फिर, कुछ समय बाद, आप `prisoner-of-azkaban` नाम का दूसरा project बनाते हैं, और यह project भी `harry` पर निर्भर करता है, लेकिन इस project को **`harry` version `3`** चाहिए।
```mermaid
flowchart LR
azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
```
लेकिन अब समस्या यह है कि अगर आप packages को local **virtual environment** में install करने के बजाय globally (global environment में) install करते हैं, तो आपको चुनना होगा कि `harry` का कौन-सा version install करना है।
अगर आप `philosophers-stone` चलाना चाहते हैं, तो आपको पहले `harry` version `1` install करना होगा, उदाहरण के लिए:
<div class="termy">
```console
$ pip install "harry==1"
```
</div>
और फिर आपके global Python environment में `harry` version `1` install हो जाएगा।
```mermaid
flowchart LR
subgraph global[global env]
harry-1[harry v1]
end
subgraph stone-project[philosophers-stone project]
stone(philosophers-stone) -->|requires| harry-1
end
```
लेकिन फिर अगर आप `prisoner-of-azkaban` चलाना चाहते हैं, तो आपको `harry` version `1` uninstall करके `harry` version `3` install करना होगा (या सिर्फ version `3` install करने से version `1` automatically uninstall हो जाएगा)।
<div class="termy">
```console
$ pip install "harry==3"
```
</div>
और फिर आपके global Python environment में `harry` version `3` install हो जाएगा।
और अगर आप `philosophers-stone` फिर से चलाने की कोशिश करते हैं, तो संभावना है कि यह **काम न करे** क्योंकि इसे `harry` version `1` चाहिए।
```mermaid
flowchart LR
subgraph global[global env]
harry-1[<strike>harry v1</strike>]
style harry-1 fill:#ccc,stroke-dasharray: 5 5
harry-3[harry v3]
end
subgraph stone-project[philosophers-stone project]
stone(philosophers-stone) -.-x|⛔️| harry-1
end
subgraph azkaban-project[prisoner-of-azkaban project]
azkaban(prisoner-of-azkaban) --> |requires| harry-3
end
```
/// tip | सुझाव
Python packages में **नए versions** में **breaking changes से बचने** की पूरी कोशिश करना बहुत आम है, लेकिन सुरक्षित रहना बेहतर है, और नए versions को जानबूझकर तथा तब install करना बेहतर है जब आप tests चलाकर जाँच सकें कि सब कुछ सही तरीके से काम कर रहा है।
///
अब, यही चीज़ उन **कई** अन्य **packages** के साथ कल्पना करें जिन पर आपके सभी **projects निर्भर करते हैं**। इसे manage करना बहुत कठिन है। और संभवतः आप कुछ projects को packages के कुछ **incompatible versions** के साथ चला देंगे, और यह नहीं जान पाएँगे कि कुछ काम क्यों नहीं कर रहा।
साथ ही, आपके operating system (जैसे Linux, Windows, macOS) के आधार पर, उसमें Python पहले से install आया हो सकता है। और उस मामले में संभवतः कुछ packages कुछ specific versions के साथ pre-installed होंगे जो **आपके system के लिए required** हैं। अगर आप global Python environment में packages install करते हैं, तो आप अपने operating system के साथ आए कुछ programs को **break** कर सकते हैं।
## Packages कहाँ install होते हैं { #where-are-packages-installed }
जब आप Python install करते हैं, तो यह आपके computer पर कुछ files वाली कुछ directories बनाता है।
इनमें से कुछ directories वे होती हैं जो आपके द्वारा install किए गए सभी packages को रखने की जिम्मेदार होती हैं।
जब आप चलाते हैं:
<div class="termy">
```console
// इसे अभी न चलाएँ, यह केवल एक उदाहरण है 🤓
$ pip install "fastapi[standard]"
---> 100%
```
</div>
तो यह FastAPI code वाली एक compressed file download करेगा, सामान्यतः [PyPI](https://pypi.org/project/fastapi/) से।
यह उन अन्य packages की files भी **download** करेगा जिन पर FastAPI निर्भर करता है।
फिर यह उन सभी files को **extract** करेगा और उन्हें आपके computer की एक directory में रखेगा।
Default रूप से, यह उन downloaded और extracted files को उस directory में रखेगा जो आपकी Python installation के साथ आती है, वही **global environment** है।
## Virtual Environments क्या हैं { #what-are-virtual-environments }
सभी packages को global environment में रखने की समस्याओं का समाधान है कि आप जिस भी project पर काम करते हैं उसके लिए **एक virtual environment** उपयोग करें।
एक virtual environment एक **directory** है, global वाली के बहुत समान, जहाँ आप किसी project के लिए packages install कर सकते हैं।
इस तरह, हर project का अपना virtual environment (`.venv` directory) होगा, अपने packages के साथ।
```mermaid
flowchart TB
subgraph stone-project[philosophers-stone project]
stone(philosophers-stone) --->|requires| harry-1
subgraph venv1[.venv]
harry-1[harry v1]
end
end
subgraph azkaban-project[prisoner-of-azkaban project]
azkaban(prisoner-of-azkaban) --->|requires| harry-3
subgraph venv2[.venv]
harry-3[harry v3]
end
end
stone-project ~~~ azkaban-project
```
## Virtual Environment activate करने का क्या मतलब है { #what-does-activating-a-virtual-environment-mean }
जब आप किसी virtual environment को activate करते हैं, उदाहरण के लिए:
//// tab | Linux, macOS
<div class="termy">
```console
$ source .venv/bin/activate
```
</div>
////
//// tab | Windows PowerShell
<div class="termy">
```console
$ .venv\Scripts\Activate.ps1
```
</div>
////
//// tab | Windows Bash
या अगर आप Windows के लिए Bash का उपयोग करते हैं (जैसे [Git Bash](https://gitforwindows.org/)):
<div class="termy">
```console
$ source .venv/Scripts/activate
```
</div>
////
वह command कुछ [environment variables](environment-variables.md) बनाएगी या modify करेगी, जो अगली commands के लिए उपलब्ध होंगे।
उन variables में से एक `PATH` variable है।
/// tip | सुझाव
आप [Environment Variables](environment-variables.md#path-environment-variable) section में `PATH` environment variable के बारे में और जान सकते हैं।
///
Virtual environment activate करने से उसका path `.venv/bin` (Linux और macOS पर) या `.venv\Scripts` (Windows पर) `PATH` environment variable में जुड़ जाता है।
मान लीजिए कि environment activate करने से पहले, `PATH` variable ऐसा दिखता था:
//// tab | Linux, macOS
```plaintext
/usr/bin:/bin:/usr/sbin:/sbin
```
इसका मतलब है कि system programs को इनमें खोजता:
* `/usr/bin`
* `/bin`
* `/usr/sbin`
* `/sbin`
////
//// tab | Windows
```plaintext
C:\Windows\System32
```
इसका मतलब है कि system programs को इसमें खोजता:
* `C:\Windows\System32`
////
Virtual environment activate करने के बाद, `PATH` variable कुछ ऐसा दिखेगा:
//// tab | Linux, macOS
```plaintext
/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin
```
इसका मतलब है कि system अब सबसे पहले programs को यहाँ खोजना शुरू करेगा:
```plaintext
/home/user/code/awesome-project/.venv/bin
```
बाकी directories में देखने से पहले।
तो, जब आप terminal में `python` type करते हैं, तो system Python program को यहाँ पाएगा
```plaintext
/home/user/code/awesome-project/.venv/bin/python
```
और उसी का उपयोग करेगा।
////
//// tab | Windows
```plaintext
C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32
```
इसका मतलब है कि system अब सबसे पहले programs को यहाँ खोजना शुरू करेगा:
```plaintext
C:\Users\user\code\awesome-project\.venv\Scripts
```
बाकी directories में देखने से पहले।
तो, जब आप terminal में `python` type करते हैं, तो system Python program को यहाँ पाएगा
```plaintext
C:\Users\user\code\awesome-project\.venv\Scripts\python
```
और उसी का उपयोग करेगा।
////
एक महत्वपूर्ण detail यह है कि यह virtual environment path को `PATH` variable की **शुरुआत** में रखेगा। System इसे किसी भी अन्य उपलब्ध Python से **पहले** पाएगा। इस तरह, जब आप `python` चलाते हैं, तो यह किसी अन्य `python` (उदाहरण के लिए, global environment वाला `python`) के बजाय **virtual environment से** Python का उपयोग करेगा।
Virtual environment activate करने से कुछ और चीजें भी बदलती हैं, लेकिन यह उसके द्वारा की जाने वाली सबसे महत्वपूर्ण चीज़ों में से एक है।
## Virtual Environment की जाँच करना { #checking-a-virtual-environment }
जब आप जाँचते हैं कि virtual environment active है या नहीं, उदाहरण के लिए:
//// tab | Linux, macOS, Windows Bash
<div class="termy">
```console
$ which python
/home/user/code/awesome-project/.venv/bin/python
```
</div>
////
//// tab | Windows PowerShell
<div class="termy">
```console
$ Get-Command python
C:\Users\user\code\awesome-project\.venv\Scripts\python
```
</div>
////
इसका मतलब है कि जो `python` program उपयोग किया जाएगा, वह **virtual environment में** मौजूद है।
आप Linux और macOS में `which` और Windows PowerShell में `Get-Command` का उपयोग करते हैं।
वह command जिस तरह काम करती है, वह यह है कि यह `PATH` environment variable में जाकर **हर path को क्रम से** check करेगी, `python` नाम के program को खोजते हुए। एक बार जब यह उसे ढूँढ लेती है, तो यह आपको उस program का **path दिखाएगी**।
सबसे महत्वपूर्ण हिस्सा यह है कि जब आप `python` call करते हैं, तो वही exact "`python`" execute होगा।
तो, आप confirm कर सकते हैं कि आप सही virtual environment में हैं या नहीं।
/// tip | सुझाव
एक virtual environment activate करना, एक Python पाना, और फिर **दूसरे project में चले जाना** आसान है।
और दूसरा project **काम नहीं करेगा** क्योंकि आप **गलत Python** का उपयोग कर रहे हैं, जो किसी दूसरे project के virtual environment से है।
यह check कर पाना उपयोगी है कि कौन-सा `python` उपयोग हो रहा है। 🤓
///
## Virtual Environment deactivate क्यों करें { #why-deactivate-a-virtual-environment }
उदाहरण के लिए, आप `philosophers-stone` project पर काम कर रहे हो सकते हैं, **उस virtual environment को activate** करके, packages install करके और उस environment के साथ काम करके।
और फिर आप **किसी दूसरे project** `prisoner-of-azkaban` पर काम करना चाहते हैं।
आप उस project में जाते हैं:
<div class="termy">
```console
$ cd ~/code/prisoner-of-azkaban
```
</div>
अगर आप `philosophers-stone` के लिए virtual environment को deactivate नहीं करते, तो जब आप terminal में `python` चलाएँगे, यह `philosophers-stone` से Python का उपयोग करने की कोशिश करेगा।
<div class="termy">
```console
$ cd ~/code/prisoner-of-azkaban
$ python main.py
// sirius import करने में error, यह install नहीं है 😱
Traceback (most recent call last):
File "main.py", line 1, in <module>
import sirius
```
</div>
लेकिन अगर आप virtual environment deactivate करके `prisoner-of-azkaban` के लिए नया वाला activate करते हैं, तो जब आप `python` चलाएँगे, यह `prisoner-of-azkaban` में मौजूद virtual environment से Python का उपयोग करेगा।
<div class="termy">
```console
$ cd ~/code/prisoner-of-azkaban
// deactivate करने के लिए आपको पुरानी directory में होने की ज़रूरत नहीं है, आप जहाँ भी हों वहाँ से कर सकते हैं, दूसरे project में जाने के बाद भी 😎
$ deactivate
// prisoner-of-azkaban/.venv में virtual environment activate करें 🚀
$ source .venv/bin/activate
// अब जब आप python चलाएँगे, तो यह इस virtual environment में install package sirius को पाएगा ✨
$ python main.py
I solemnly swear 🐺
```
</div>
## Alternatives { #alternatives }
यह आपको शुरू करने और यह सिखाने के लिए एक सरल guide है कि सब कुछ **अंदर से** कैसे काम करता है।
Virtual environments, package dependencies (requirements), projects को manage करने के कई **alternatives** हैं।
जब आप तैयार हों और **पूरे project को manage** करने के लिए कोई tool उपयोग करना चाहें, package dependencies, virtual environments आदि सहित, तो मैं सुझाव दूँगा कि आप [uv](https://github.com/astral-sh/uv) आज़माएँ।
`uv` बहुत सारी चीज़ें कर सकता है, यह कर सकता है:
* आपके लिए **Python install** करना, अलग-अलग versions सहित
* आपके projects के लिए **virtual environment** manage करना
* **Packages** install करना
* आपके project के लिए package **dependencies और versions** manage करना
* सुनिश्चित करना कि आपके पास install करने के लिए packages और versions का **exact** set हो, उनकी dependencies सहित, ताकि आप सुनिश्चित हो सकें कि आप अपने project को production में ठीक उसी तरह चला सकते हैं जैसे development के दौरान अपने computer पर चलाते हैं, इसे **locking** कहा जाता है
* और कई अन्य चीज़ें
## निष्कर्ष { #conclusion }
अगर आपने यह सब पढ़ा और समझा है, तो अब **आप virtual environments के बारे में** वहाँ मौजूद कई developers से कहीं ज़्यादा जानते हैं। 🤓
इन details को जानना भविष्य में उस समय बहुत संभवतः उपयोगी होगा जब आप किसी ऐसी चीज़ को debug कर रहे होंगे जो complex लगती है, लेकिन आपको पता होगा कि **यह सब अंदर से कैसे काम करता है**। 😎
Virtual environments अंदर से कैसे काम करते हैं, यह जानने के लिए [Virtual Environments guide](https://tiangolo.com/guides/virtual-environments/) पढ़ें, जिसमें activation और alternative `python -m venv` और `pip` workflow शामिल हैं।