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

2026-09-11 04:00:08 +00:00
parent 632909b5f6
commit 818066b271
739 changed files with 4974 additions and 17395 deletions
@@ -243,5 +243,5 @@ Bu tekniği, *path operation*'larınızda bazı ön tanımlı response'ları yen

 Response'ların içine tam olarak neleri dahil edebileceğinizi görmek için OpenAPI spesifikasyonundaki şu bölümlere bakabilirsiniz:

-* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), `Response Object`'i içerir.
-* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), buradaki her şeyi `responses` parametreniz içinde, her bir response'un içine doğrudan ekleyebilirsiniz. Buna `description`, `headers`, `content` (bunun içinde farklı media type'lar ve JSON Schema'lar tanımlarsınız) ve `links` dahildir.
+* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object), `Response Object`'i içerir.
+* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object), buradaki her şeyi `responses` parametreniz içinde, her bir response'un içine doğrudan ekleyebilirsiniz. Buna `description`, `headers`, `content` (bunun içinde farklı media type'lar ve JSON Schema'lar tanımlarsınız) ve `links` dahildir.
@@ -45,7 +45,7 @@ Testlerinizi her zamanki gibi şu şekilde çalıştırabilirsiniz:
 <div class="termy">

 ```console
-$ pytest
+$ uv run pytest

 ---> 100%
 ```
@@ -33,7 +33,7 @@ Bunu `--forwarded-allow-ips="*"` olarak ayarlarsanız, gelen tüm IP'lere güven
 <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 @@ Bunu yapmak için `--root-path` komut satırı seçeneğini şöyle kullanabilir
 <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 @@ Ardından Uvicorn'u şu şekilde başlatırsanız:
 <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 @@ Böyle bir durumda (stripped path prefix olmadan), proxy `https://myawesomeapp.c

 [Traefik](https://docs.traefik.io/) kullanarak, stripped path prefix'li deneyi local'de kolayca çalıştırabilirsiniz.

-[Traefik'i indirin](https://github.com/containous/traefik/releases); tek bir binary'dir, sıkıştırılmış dosyayı çıkarıp doğrudan terminalden çalıştırabilirsiniz.
+[Traefik'i indirin](https://github.com/traefik/traefik/releases); tek bir binary'dir, sıkıştırılmış dosyayı çıkarıp doğrudan terminalden çalıştırabilirsiniz.

 Ardından `traefik.toml` adında bir dosya oluşturup şunu yazın:

@@ -321,7 +321,7 @@ Ve şimdi uygulamanızı `--root-path` seçeneğiyle başlatın:
 <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)
 ```
@@ -7,7 +7,7 @@ Ancak FastAPI, [`dataclasses`](https://docs.python.org/3/library/dataclasses.htm

 {* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}

-Bu destek hâlâ **Pydantic** sayesinde vardır; çünkü Pydantic, [`dataclasses` için dahili destek](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel) sunar.
+Bu destek hâlâ **Pydantic** sayesinde vardır; çünkü Pydantic, [`dataclasses` için dahili destek](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/#usage-of-stdlib-dataclasses-with-basemodel) sunar.

 Yani yukarıdaki kod Pydantic'i doğrudan kullanmasa bile, FastAPI bu standart dataclass'ları Pydantic'in kendi dataclass biçimine dönüştürmek için Pydantic'i kullanmaktadır.

@@ -89,7 +89,7 @@ Daha spesifik ayrıntılar için yukarıdaki kod içi annotation ipuçlarına ba

 `dataclasses`'ı diğer Pydantic model'leriyle de birleştirebilir, onlardan kalıtım alabilir, kendi model'lerinize dahil edebilirsiniz, vb.

-Daha fazlası için [Pydantic'in dataclasses dokümantasyonuna](https://docs.pydantic.dev/latest/concepts/dataclasses/) bakın.
+Daha fazlası için [Pydantic'in dataclasses dokümantasyonuna](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/) bakın.

 ## Sürüm { #version }

@@ -154,7 +154,7 @@ Altta, ASGI teknik spesifikasyonunda bu, [Lifespan Protokolü](https://asgi.read

 /// note | Not

-Starlette `lifespan` handler’ları hakkında daha fazlasını [Starlette Lifespan dokümanları](https://www.starlette.dev/lifespan/) içinde okuyabilirsiniz.
+Starlette `lifespan` handler’ları hakkında daha fazlasını [Starlette Lifespan dokümanları](https://starlette.dev/lifespan/) içinde okuyabilirsiniz.

 Ayrıca kodunuzun başka bölgelerinde de kullanılabilecek lifespan state’i nasıl yöneteceğinizi de kapsar.

@@ -12,7 +12,7 @@ Esnek bir seçenek olan [OpenAPI Generator](https://openapi-generator.tech/), **

 **TypeScript client**'lar için [Hey API](https://heyapi.dev/), TypeScript ekosistemi için özel olarak tasarlanmış, optimize bir deneyim sunan bir çözümdür.

-Daha fazla SDK üretecini [OpenAPI.Tools](https://openapi.tools/#sdk) üzerinde keşfedebilirsiniz.
+Daha fazla SDK üretecini [OpenAPI.Tools](https://openapi.tools/categories/sdk-generators) üzerinde keşfedebilirsiniz.

 /// tip | İpucu

@@ -91,7 +91,7 @@ Başka birçok ASGI middleware'i vardır.

 Örneğin:

-* [Uvicorn'un `ProxyHeadersMiddleware`'i](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
+* [Uvicorn'un `ProxyHeadersMiddleware`'i](https://github.com/Kludex/uvicorn/blob/main/uvicorn/middleware/proxy_headers.py)
 * [MessagePack](https://github.com/florimondmanca/msgpack-asgi)

-Diğer mevcut middleware'leri görmek için [Starlette'in Middleware dokümanlarına](https://www.starlette.dev/middleware/) ve [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi) listesine bakın.
+Diğer mevcut middleware'leri görmek için [Starlette'in Middleware dokümanlarına](https://starlette.dev/middleware/) ve [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi) listesine bakın.
@@ -35,7 +35,7 @@ Bu kısım oldukça standart; kodun çoğu muhtemelen size zaten tanıdık gelec

 /// tip | İpucu

-`callback_url` query parametresi, Pydantic'in [Url](https://docs.pydantic.dev/latest/api/networks/) tipini kullanır.
+`callback_url` query parametresi, Pydantic'in [Url](https://pydantic.dev/docs/validation/latest/api/pydantic/networks/) tipini kullanır.

 ///

@@ -106,11 +106,11 @@ Normal bir FastAPI *path operation*'ı gibi görünmelidir:
 Normal bir *path operation*'dan 2 temel farkı vardır:

 * Gerçek bir koda ihtiyaç duymaz; çünkü uygulamanız bu kodu asla çağırmayacak. Bu yalnızca *external API*'yi dokümante etmek için kullanılır. Yani fonksiyon sadece `pass` içerebilir.
-* *path*, bir [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (aşağıda daha fazlası) içerebilir; böylece parametreler ve sizin API'nize gönderilen orijinal request'in bazı parçalarıyla değişkenler kullanılabilir.
+* *path*, bir [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) (aşağıda daha fazlası) içerebilir; böylece parametreler ve sizin API'nize gönderilen orijinal request'in bazı parçalarıyla değişkenler kullanılabilir.

 ### Callback path ifadesi { #the-callback-path-expression }

-Callback *path*'i, sizin API'nize gönderilen orijinal request'in bazı parçalarını içerebilen bir [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) barındırabilir.
+Callback *path*'i, sizin API'nize gönderilen orijinal request'in bazı parçalarını içerebilen bir [OpenAPI 3 expression](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) barındırabilir.

 Bu örnekte, bu bir `str`:

@@ -48,4 +48,4 @@ Ve `Response`, header ve cookie set etmek için sık kullanıldığından, **Fas

 ///

-Mevcut tüm parametreleri ve seçenekleri görmek için [Starlette dokümantasyonu](https://www.starlette.dev/responses/#set-cookie)'na bakın.
+Mevcut tüm parametreleri ve seçenekleri görmek için [Starlette dokümantasyonu](https://starlette.dev/responses/#set-cookie)'na bakın.
@@ -1,6 +1,5 @@
 # Response Header'ları { #response-headers }

-
 ## Bir `Response` parametresi kullanın { #use-a-response-parameter }

 *Path operation function* içinde (cookie'lerde yapabildiğiniz gibi) tipi `Response` olan bir parametre tanımlayabilirsiniz.
@@ -39,4 +38,4 @@ Ayrıca `Response` header ve cookie ayarlamak için sık kullanıldığından, *

 Özel/proprietary header'ların [`X-` prefix'i kullanılarak](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) eklenebileceğini unutmayın.

-Ancak tarayıcıdaki bir client'ın görebilmesini istediğiniz özel header'larınız varsa, bunları CORS ayarlarınıza eklemeniz gerekir ([CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) bölümünde daha fazla bilgi), bunun için [Starlette'in CORS dokümanında](https://www.starlette.dev/middleware/#corsmiddleware) açıklanan `expose_headers` parametresini kullanın.
+Ancak tarayıcıdaki bir client'ın görebilmesini istediğiniz özel header'larınız varsa, bunları CORS ayarlarınıza eklemeniz gerekir ([CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) bölümünde daha fazla bilgi), bunun için [Starlette'in CORS dokümanında](https://starlette.dev/middleware/#corsmiddleware) açıklanan `expose_headers` parametresini kullanın.
@@ -1,15 +1,18 @@
 # Ayarlar ve Ortam Değişkenleri { #settings-and-environment-variables }

-
 Birçok durumda uygulamanızın bazı harici ayarlara veya konfigürasyonlara ihtiyacı olabilir; örneğin secret key'ler, veritabanı kimlik bilgileri, e-posta servisleri için kimlik bilgileri vb.

 Bu ayarların çoğu değişkendir (değişebilir); örneğin veritabanı URL'leri. Ayrıca birçoğu hassas olabilir; örneğin secret'lar.

 Bu nedenle bunları, uygulama tarafından okunan environment variable'lar ile sağlamak yaygındır.

+Bir **environment variable** (**env var** olarak da bilinir), Python kodunun dışında, işletim sisteminde yaşayan ve uygulamanız ile diğer programlar tarafından okunabilen bir değerdir.
+
+Bir komutu çalıştırırken o komut için bir environment variable oluşturabilirsiniz. Platforma özel komutları aşağıda göreceksiniz.
+
 /// tip | İpucu

-Environment variable'ları anlamak için [Ortam Değişkenleri](../environment-variables.md) dokümanını okuyabilirsiniz.
+Environment variable'ların nasıl çalıştığına dair ayrıntılı bir açıklama için [Environment Variables rehberini](https://tiangolo.com/guides/environment-variables/) okuyabilirsiniz.

 ///

@@ -21,16 +24,16 @@ Bu da, Python içinde bir environment variable'dan okunan herhangi bir değerin

 ## Pydantic `Settings` { #pydantic-settings }

-Neyse ki Pydantic, environment variable'lardan gelen bu ayarları yönetmek için [Pydantic: Settings yönetimi](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) ile çok iyi bir yardımcı araç sunar.
+Neyse ki Pydantic, environment variable'lardan gelen bu ayarları yönetmek için [Pydantic: Settings yönetimi](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) ile çok iyi bir yardımcı araç sunar.

 ### `pydantic-settings`'i kurun { #install-pydantic-settings }

-Önce, [Sanal ortam](../virtual-environments.md) oluşturduğunuzdan, aktive ettiğinizden emin olun ve ardından `pydantic-settings` paketini kurun:
+`pydantic-settings` paketini projenize ekleyin:

 <div class="termy">

 ```console
-$ pip install pydantic-settings
+$ uv add pydantic-settings
 ---> 100%
 ```

@@ -41,7 +44,7 @@ Ayrıca `all` extras'ını şu şekilde kurduğunuzda da dahil gelir:
 <div class="termy">

 ```console
-$ pip install "fastapi[all]"
+$ uv add "fastapi[all]"
 ---> 100%
 ```

@@ -77,19 +80,39 @@ Daha sonra uygulamanızda yeni `settings` nesnesini kullanabilirsiniz:

 Sonraki adımda server'ı çalıştırırken konfigürasyonları environment variable olarak geçersiniz; örneğin `ADMIN_EMAIL` ve `APP_NAME` şu şekilde ayarlanabilir:

+//// 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 | İpucu

-Tek bir komut için birden fazla env var ayarlamak istiyorsanız aralarına boşluk koyun ve hepsini komuttan önce yazın.
+Bash'te, tek bir komut için birden fazla env var ayarlamak istiyorsanız aralarına boşluk koyun ve hepsini komuttan önce yazın.

 ///

@@ -173,11 +196,11 @@ Ancak dotenv dosyasının mutlaka bu dosya adına sahip olması gerekmez.

 ///

-Pydantic, harici bir kütüphane kullanarak bu tür dosyalardan okuma desteğine sahiptir. Daha fazlası için: [Pydantic Settings: Dotenv (.env) desteği](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
+Pydantic, harici bir kütüphane kullanarak bu tür dosyalardan okuma desteğine sahiptir. Daha fazlası için: [Pydantic Settings: Dotenv (.env) desteği](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support).

 /// tip | İpucu

-Bunun çalışması için `pip install python-dotenv` yapmanız gerekir.
+Bunun çalışması için `uv add python-dotenv` ile `python-dotenv` paketini projenize ekleyin.

 ///

@@ -198,7 +221,7 @@ Ardından `config.py` dosyanızı şöyle güncelleyin:

 /// tip | İpucu

-`model_config` attribute'u yalnızca Pydantic konfigürasyonu içindir. Daha fazlası için [Pydantic: Kavramlar: Konfigürasyon](https://docs.pydantic.dev/latest/concepts/config/).
+`model_config` attribute'u yalnızca Pydantic konfigürasyonu içindir. Daha fazlası için [Pydantic: Kavramlar: Konfigürasyon](https://pydantic.dev/docs/validation/latest/concepts/config/).

 ///

@@ -35,7 +35,7 @@ Bu örnekte `/subapi` path’ine mount edilecektir:
 <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)
 ```
@@ -8,12 +8,12 @@ Bunu kolayca yapılandırmak için, doğrudan **FastAPI** uygulamanızda kullana

 ## Bağımlılıkları Yükleme { #install-dependencies }

-Bir [sanal ortam](../virtual-environments.md) oluşturduğunuzdan, etkinleştirdiğinizden ve `jinja2`'yi yüklediğinizden emin olun:
+Projenize `jinja2` ekleyin:

 <div class="termy">

 ```console
-$ pip install jinja2
+$ uv add jinja2

 ---> 100%
 ```
@@ -123,4 +123,4 @@ Ve `StaticFiles` kullandığınız için, bu CSS dosyası **FastAPI** uygulaman

 ## Daha fazla detay { #more-details }

-Template'leri nasıl test edeceğiniz dahil daha fazla detay için [Starlette'in template dokümantasyonuna](https://www.starlette.dev/templates/) bakın.
+Template'leri nasıl test edeceğiniz dahil daha fazla detay için [Starlette'in template dokümantasyonuna](https://starlette.dev/templates/) bakın.
@@ -5,7 +5,7 @@ Test'lerinizde `lifespan`'ın çalışması gerektiğinde, `TestClient`'ı bir `
 {* ../../docs_src/app_testing/tutorial004_py310.py hl[9:15,18,27:28,30:32,41:43] *}


-Bu konuda daha fazla ayrıntıyı resmi Starlette dokümantasyon sitesindeki ["Testlerde lifespan'ı çalıştırma"](https://www.starlette.dev/lifespan/#running-lifespan-in-tests) bölümünde okuyabilirsiniz.
+["Resmi Starlette dokümantasyon sitesinde testlerde lifespan'ı çalıştırma."](https://starlette.dev/lifespan/#running-lifespan-in-tests) hakkında daha fazla ayrıntı okuyabilirsiniz.

 Kullanımdan kaldırılmış `startup` ve `shutdown` event'leri için ise `TestClient`'ı aşağıdaki gibi kullanabilirsiniz:

@@ -8,6 +8,6 @@ Bunun için `TestClient`'ı bir `with` ifadesinde kullanarak WebSocket'e bağlan

 /// note | Not

-Daha fazla detay için Starlette'in [WebSockets'i test etme](https://www.starlette.dev/testclient/#testing-websocket-sessions) dokümantasyonuna bakın.
+Daha fazla detay için Starlette'in [WebSockets'i test etme](https://starlette.dev/testclient/#testing-websocket-sessions) dokümantasyonuna bakın.

 ///
@@ -15,7 +15,7 @@ Ancak bazı durumlarda `Request` nesnesine doğrudan erişmeniz gerekebilir.

 ## `Request` nesnesi hakkında detaylar { #details-about-the-request-object }

-**FastAPI** aslında altta **Starlette** çalıştırır ve üstüne çeşitli araçlardan oluşan bir katman ekler. Bu yüzden gerektiğinde Starlette'in [`Request`](https://www.starlette.dev/requests/) nesnesini doğrudan kullanabilirsiniz.
+**FastAPI** aslında altta **Starlette** çalıştırır ve üstüne çeşitli araçlardan oluşan bir katman ekler. Bu yüzden gerektiğinde Starlette'in [`Request`](https://starlette.dev/requests/) nesnesini doğrudan kullanabilirsiniz.

 Bu ayrıca şu anlama gelir: `Request` nesnesinden veriyi doğrudan alırsanız (örneğin body'yi okursanız) FastAPI bu veriyi doğrulamaz, dönüştürmez veya dokümante etmez (otomatik API arayüzü için OpenAPI ile).

@@ -45,7 +45,7 @@ Aynı şekilde, diğer parameter'ları normal biçimde tanımlamaya devam edip b

 ## `Request` dokümantasyonu { #request-documentation }

-[Resmi Starlette dokümantasyon sitesinde `Request` nesnesiyle ilgili daha fazla detayı](https://www.starlette.dev/requests/) okuyabilirsiniz.
+[Resmi Starlette dokümantasyon sitesinde `Request` nesnesiyle ilgili daha fazla detayı](https://starlette.dev/requests/) okuyabilirsiniz.

 /// note | Teknik Detaylar

@@ -4,12 +4,12 @@

 ## `websockets` Kurulumu { #install-websockets }

-Bir [sanal ortam](../virtual-environments.md) oluşturduğunuzdan, onu aktive ettiğinizden ve `websockets`'i ("WebSocket" protokolünü kullanmayı kolaylaştıran bir Python kütüphanesi) kurduğunuzdan emin olun:
+Projenize `websockets`'i ("WebSocket" protokolünü kullanmayı kolaylaştıran bir Python kütüphanesi) ekleyin:

 <div class="termy">

 ```console
-$ pip install websockets
+$ uv add websockets

 ---> 100%
 ```
@@ -69,7 +69,7 @@ Kodunuzu `main.py` dosyasına koyun ve ardından uygulamanızı çalıştırın:
 <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)
 ```
@@ -111,7 +111,7 @@ Diğer FastAPI endpoint'leri/*path operations* ile aynı şekilde çalışırlar

 {* ../../docs_src/websockets_/tutorial002_an_py310.py hl[68:69,82] *}

-/// note
+/// note | Not

 Bu bir WebSocket olduğu için `HTTPException` raise etmek pek anlamlı değildir; bunun yerine `WebSocketException` raise ederiz.

@@ -126,7 +126,7 @@ Uygulamanızı çalıştırın:
 <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)
 ```
@@ -140,7 +140,7 @@ Burada şunları ayarlayabilirsiniz:
 * path'te kullanılan "Item ID".
 * query parametresi olarak kullanılan "Token".

-/// tip
+/// tip | İpucu

 query'deki `token` değerinin bir dependency tarafından ele alınacağına dikkat edin.

@@ -168,7 +168,7 @@ Bu, `WebSocketDisconnect` exception'ını raise eder ve diğer tüm client'lar
 Client #1596980209979 left the chat
 ```

-/// tip
+/// tip | İpucu

 Yukarıdaki uygulama, birden fazla WebSocket bağlantısına mesajları nasıl yönetip broadcast edeceğinizi göstermek için minimal ve basit bir örnektir.

@@ -182,5 +182,5 @@ FastAPI ile kolay entegre olan ama Redis, PostgreSQL vb. tarafından desteklenen

 Seçenekler hakkında daha fazlasını öğrenmek için Starlette dokümantasyonunda şunlara bakın:

-* [`WebSocket` class'ı](https://www.starlette.dev/websockets/).
-* [Class tabanlı WebSocket yönetimi](https://www.starlette.dev/endpoints/#websocketendpoint).
+* [`WebSocket` class'ı](https://starlette.dev/websockets/).
+* [Class tabanlı WebSocket yönetimi](https://starlette.dev/endpoints/#websocketendpoint).
@@ -1,6 +1,5 @@
 # WSGI'yi Dahil Etme - Flask, Django ve Diğerleri { #including-wsgi-flask-django-others }

-
 WSGI uygulamalarını [Alt Uygulamalar - Mount Etme](sub-applications.md), [Bir Proxy Arkasında](behind-a-proxy.md) bölümlerinde gördüğünüz gibi mount edebilirsiniz.

 Bunun için `WSGIMiddleware`'ı kullanabilir ve bunu WSGI uygulamanızı (örneğin Flask, Django vb.) sarmalamak için kullanabilirsiniz.
@@ -9,7 +8,7 @@ Bunun için `WSGIMiddleware`'ı kullanabilir ve bunu WSGI uygulamanızı (örne

 /// note | Not

-Bunun için `a2wsgi` kurulmalıdır; örneğin `pip install a2wsgi` ile.
+Bunun için projenize `a2wsgi` eklemeniz gerekir; örneğin `uv add a2wsgi` ile.

 ///

@@ -125,7 +125,7 @@ API spesifikasyonları için özel bir şema yerine açık bir standart benimsem
 Ve standartlara dayalı kullanıcı arayüzü araçlarını entegre etmek:

 * [Swagger UI](https://github.com/swagger-api/swagger-ui)
-* [ReDoc](https://github.com/Rebilly/ReDoc)
+* [ReDoc](https://github.com/Redocly/redoc)

 Bu ikisi oldukça popüler ve istikrarlı oldukları için seçildi; hızlı bir aramayla OpenAPI için onlarca alternatif kullanıcı arayüzü bulabilirsiniz (**FastAPI** ile de kullanabilirsiniz).

@@ -237,7 +237,7 @@ Serileştirme ve doğrulamayı tanımlayan aynı koddan, OpenAPI şemasını oto

 ///

-### [NestJS](https://nestjs.com/) (ve [Angular](https://angular.io/)) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (ve [Angular](https://angular.dev/)) { #nestjs-and-angular }

 Bu Python bile değil; NestJS, Angular’dan ilham alan bir JavaScript (TypeScript) NodeJS framework’üdür.

@@ -337,7 +337,7 @@ Senkron Python web framework’leri için önceki standart olan WSGI’ye dayand

 /// note | Not

-Hug, Python dosyalarındaki import’ları otomatik sıralayan harika bir araç olan [`isort`](https://github.com/timothycrosley/isort)’un geliştiricisi Timothy Crosley tarafından geliştirildi.
+Hug, Python dosyalarındaki import’ları otomatik sıralayan harika bir araç olan [`isort`](https://github.com/PyCQA/isort)’un geliştiricisi Timothy Crosley tarafından geliştirildi.

 ///

@@ -380,7 +380,7 @@ Artık bir API web framework’ü değildi; geliştirici Starlette’e odaklanma
 APIStar, aşağıdakilerin de yaratıcısı olan Tom Christie tarafından geliştirildi:

 * Django REST Framework
-* **FastAPI**’ın üzerine kurulu Starlette
+* **FastAPI**’nin temel aldığı Starlette
 * Starlette ve **FastAPI** tarafından kullanılan Uvicorn

 ///
@@ -401,7 +401,7 @@ Sonra APIStar bir sunucu olarak var olmaktan çıktı ve Starlette oluşturuldu;

 ## **FastAPI** Tarafından Kullanılanlar { #used-by-fastapi }

-### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
+### [Pydantic](https://pydantic.dev/docs/) { #pydantic }

 Pydantic, Python tip belirteçlerine dayalı olarak veri doğrulama, serileştirme ve dökümantasyon (JSON Schema kullanarak) tanımlamak için bir kütüphanedir.

@@ -417,7 +417,7 @@ Tüm veri doğrulama, veri serileştirme ve JSON Schema tabanlı otomatik model

 ///

-### [Starlette](https://www.starlette.dev/) { #starlette }
+### [Starlette](https://starlette.dev/) { #starlette }

 Starlette, yüksek performanslı asyncio servisleri oluşturmak için ideal, hafif bir <dfn title="Asenkron Python web uygulamaları geliştirmek için yeni standart">ASGI</dfn> framework’ü/araç takımıdır.

@@ -462,7 +462,7 @@ Dolayısıyla Starlette ile yapabildiğiniz her şeyi, adeta “turbo şarjlı S

 ///

-### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
+### [Uvicorn](https://uvicorn.dev) { #uvicorn }

 Uvicorn, uvloop ve httptools üzerinde inşa edilmiş, ışık hızında bir ASGI sunucusudur.

@@ -105,36 +105,32 @@ Bu, örneğin şu durumlarda **çoğu zaman** yapmak isteyeceğiniz şeydir:

 ### Paket Gereksinimleri { #package-requirements }

-Uygulamanızın **paket gereksinimleri** genelde bir dosyada yer alır.
+Projenizi `uv` ile yönetiyorsanız, doğrudan bağımlılıkları `pyproject.toml` içinde tanımlanır ve çözümlenen kesin versiyonlar `uv.lock` içinde saklanır.

-Bu, gereksinimleri **yüklemek** için kullandığınız araca göre değişir.
-
-En yaygın yöntem, paket adları ve versiyonlarının satır satır yazıldığı bir `requirements.txt` dosyasına sahip olmaktır.
-
-Versiyon aralıklarını belirlemek için elbette [FastAPI sürümleri hakkında](versions.md) bölümünde okuduğunuz fikirleri kullanırsınız.
-
-Örneğin `requirements.txt` şöyle görünebilir:
-
-```
-fastapi[standard]>=0.113.0,<0.114.0
-pydantic>=2.7.0,<3.0.0
-```
-
-Ve bu bağımlılıkları normalde `pip` ile yüklersiniz, örneğin:
+Uygulamanızın ihtiyaç duyduğu paketleri şu şekilde ekleyebilirsiniz:

 <div class="termy">

 ```console
-$ pip install -r requirements.txt
+$ uv add "fastapi[standard]" pydantic
 ---> 100%
-Successfully installed fastapi pydantic
 ```

 </div>

 /// note | Not

-Paket bağımlılıklarını tanımlamak ve yüklemek için başka formatlar ve araçlar da vardır.
+Aşağıdaki Dockerfile, container içinde `pip` kullanır. uv projenizdeki kilitlenmiş bağımlılıkları, beklediği `requirements.txt` formatına export edebilirsiniz:
+
+<div class="termy">
+
+```console
+$ uv export --format requirements-txt --no-dev --no-emit-project --output-file requirements.txt
+```
+
+</div>
+
+Oluşturulan `requirements.txt`, container build'i için bir export'tur. Bağımlılıkları `uv add` ile yönetmeye devam edin ve `uv.lock` değiştiğinde bu dosyayı yeniden oluşturun.

 ///

@@ -372,7 +368,7 @@ Otomatik etkileşimli API dokümantasyonunu görürsünüz ( [Swagger UI](https:

 Ayrıca [http://192.168.99.100/redoc](http://192.168.99.100/redoc) veya [http://127.0.0.1/redoc](http://127.0.0.1/redoc) adresine de gidebilirsiniz (ya da Docker host'unuzla eşdeğeri).

-Alternatif otomatik dokümantasyonu görürsünüz ([ReDoc](https://github.com/Rebilly/ReDoc) tarafından sağlanır):
+Alternatif otomatik dokümantasyonu görürsünüz ([ReDoc](https://github.com/Redocly/redoc) tarafından sağlanır):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -5,7 +5,7 @@ FastAPI uygulamanızı [FastAPI Cloud](https://fastapicloud.com)'a yalnızca **t
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -1,6 +1,5 @@
 # Bir Sunucuyu Manuel Olarak Çalıştırın { #run-a-server-manually }

-
 ## `fastapi run` Komutunu Kullanın { #use-the-fastapi-run-command }

 Kısacası, FastAPI uygulamanızı sunmak için `fastapi run` kullanın:
@@ -53,7 +52,7 @@ Uzak bir sunucu makinesinde **FastAPI** uygulamasını (veya herhangi bir ASGI u

 Buna alternatif birkaç seçenek daha vardır, örneğin:

-* [Uvicorn](https://www.uvicorn.dev/): yüksek performanslı bir ASGI server.
+* [Uvicorn](https://uvicorn.dev): yüksek performanslı bir ASGI server.
 * [Hypercorn](https://hypercorn.readthedocs.io/): diğer özelliklerin yanında HTTP/2 ve Trio ile uyumlu bir ASGI server.
 * [Daphne](https://github.com/django/daphne): Django Channels için geliştirilmiş ASGI server.
 * [Granian](https://github.com/emmett-framework/granian): Python uygulamaları için bir Rust HTTP server.
@@ -74,14 +73,14 @@ FastAPI'yi kurduğunuzda, production sunucusu olarak Uvicorn da beraberinde geli

 Ancak bir ASGI server'ı manuel olarak da kurabilirsiniz.

-Bir [sanal ortam](../virtual-environments.md) oluşturduğunuzdan, etkinleştirdiğinizden emin olun; ardından server uygulamasını kurabilirsiniz.
+Server uygulamasını projenize ekleyin.

 Örneğin Uvicorn'u kurmak için:

 <div class="termy">

 ```console
-$ pip install "uvicorn[standard]"
+$ uv add "uvicorn[standard]"

 ---> 100%
 ```
@@ -96,7 +95,7 @@ Benzer bir süreç, diğer ASGI server programlarının tamamı için de geçerl

 Bunlara, `asyncio` için yüksek performanslı bir drop-in replacement olan ve concurrency performansını ciddi şekilde artıran `uvloop` da dahildir.

-FastAPI'yi `pip install "fastapi[standard]"` gibi bir şekilde kurduğunuzda `uvicorn[standard]` da zaten kurulmuş olur.
+FastAPI'yi `uv add "fastapi[standard]"` gibi bir şekilde eklediğinizde `uvicorn[standard]` da zaten kurulmuş olur.

 ///

@@ -107,7 +106,7 @@ Bir ASGI server'ı manuel olarak kurduysanız, FastAPI uygulamanızı import ede
 <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)
 ```
@@ -9,19 +9,19 @@
 * Bellek
 * Başlatmadan önceki adımlar

-Bu noktaya kadar, dokümantasyondaki tüm tutorial'larla muhtemelen bir server programı çalıştırıyordunuz; örneğin Uvicorn'u çalıştıran `fastapi` komutunu kullanarak ve tek bir process ile.
+Bu noktaya kadar, dokümantasyondaki tüm tutorial'larla muhtemelen bir **server programı** çalıştırıyordunuz; örneğin Uvicorn'u çalıştıran `fastapi` komutunu kullanarak ve **tek bir process** ile.

-Uygulamaları deploy ederken, çok çekirdekten (multiple cores) faydalanmak ve daha fazla request'i karşılayabilmek için büyük olasılıkla process replikasyonu (birden fazla process) isteyeceksiniz.
+Uygulamaları deploy ederken, çok çekirdekten (multiple cores) faydalanmak ve daha fazla request'i karşılayabilmek için büyük olasılıkla **process replikasyonu (birden fazla process)** isteyeceksiniz.

 [Daha önceki Deployment Concepts](concepts.md) bölümünde gördüğünüz gibi, kullanabileceğiniz birden fazla strateji var.

-Burada, `fastapi` komutunu kullanarak ya da `uvicorn` komutunu doğrudan çalıştırarak worker process'lerle Uvicorn'u nasıl kullanacağınızı göstereceğim.
+Burada, `fastapi` komutunu kullanarak ya da `uvicorn` komutunu doğrudan çalıştırarak **worker process**'lerle **Uvicorn**'u nasıl kullanacağınızı göstereceğim.

 /// note | Not

 Container kullanıyorsanız (örneğin Docker veya Kubernetes ile), bununla ilgili daha fazlasını bir sonraki bölümde anlatacağım: [Container'larda FastAPI - Docker](docker.md).

-Özellikle Kubernetes üzerinde çalıştırırken, büyük olasılıkla worker kullanmak istemeyeceksiniz; bunun yerine container başına tek bir Uvicorn process çalıştırmak daha uygundur. Ancak bunu da o bölümde detaylandıracağım.
+Özellikle **Kubernetes** üzerinde çalıştırırken, büyük olasılıkla worker kullanmak istemeyeceksiniz; bunun yerine **container başına tek bir Uvicorn process** çalıştırmak daha uygundur. Ancak bunu da o bölümde detaylandıracağım.

 ///

@@ -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>]
@@ -109,13 +109,13 @@ $ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4

 Buradaki tek yeni seçenek `--workers`; bu seçenek Uvicorn'a 4 adet worker process başlatmasını söyler.

-Ayrıca her process'in PID'inin gösterildiğini de görebilirsiniz: parent process için `27365` (bu process manager), her worker process için de bir PID: `27368`, `27369`, `27370` ve `27367`.
+Ayrıca her process'in **PID**'inin gösterildiğini de görebilirsiniz: parent process için `27365` (bu **process manager**), her worker process için de bir PID: `27368`, `27369`, `27370` ve `27367`.

 ## Deployment Kavramları { #deployment-concepts }

-Burada, uygulamanın çalışmasını paralelleştirmek, CPU'daki çok çekirdekten yararlanmak ve daha fazla request karşılayabilmek için birden fazla worker'ı nasıl kullanacağınızı gördünüz.
+Burada, uygulamanın çalışmasını **paralelleştirmek**, CPU'daki **çok çekirdekten** yararlanmak ve **daha fazla request** karşılayabilmek için birden fazla **worker**'ı nasıl kullanacağınızı gördünüz.

-Yukarıdaki deployment kavramları listesinden, worker kullanımı ağırlıklı olarak replikasyon kısmına yardımcı olur, ayrıca yeniden başlatmalar konusunda da az da olsa katkı sağlar. Ancak diğerlerini yine sizin yönetmeniz gerekir:
+Yukarıdaki deployment kavramları listesinden, worker kullanımı ağırlıklı olarak **replikasyon** kısmına yardımcı olur, ayrıca **yeniden başlatmalar** konusunda da az da olsa katkı sağlar. Ancak diğerlerini yine sizin yönetmeniz gerekir:

 * **Güvenlik - HTTPS**
 * **Başlangıçta çalıştırma**
@@ -126,14 +126,14 @@ Yukarıdaki deployment kavramları listesinden, worker kullanımı ağırlıklı

 ## Container'lar ve Docker { #containers-and-docker }

-Bir sonraki bölümde, [Container'larda FastAPI - Docker](docker.md) üzerinden diğer deployment kavramlarını ele almak için kullanabileceğiniz bazı stratejileri anlatacağım.
+Bir sonraki bölümde, [Container'larda FastAPI - Docker](docker.md) üzerinden diğer **deployment kavramlarını** ele almak için kullanabileceğiniz bazı stratejileri anlatacağım.

-Tek bir Uvicorn process çalıştıracak şekilde sıfırdan kendi image'ınızı oluşturmayı göstereceğim. Bu oldukça basit bir süreçtir ve Kubernetes gibi dağıtık bir container yönetim sistemi kullanırken büyük olasılıkla yapmak isteyeceğiniz şey de budur.
+Tek bir Uvicorn process çalıştıracak şekilde **sıfırdan kendi image'ınızı oluşturmayı** göstereceğim. Bu oldukça basit bir süreçtir ve **Kubernetes** gibi dağıtık bir container yönetim sistemi kullanırken büyük olasılıkla yapmak isteyeceğiniz şey de budur.

 ## Özet { #recap }

-Çok çekirdekli CPU'lardan faydalanmak ve birden fazla process'i paralel çalıştırmak için `fastapi` veya `uvicorn` komutlarıyla `--workers` CLI seçeneğini kullanarak birden fazla worker process çalıştırabilirsiniz.
+Çok çekirdekli CPU'lardan faydalanmak ve **birden fazla process'i paralel çalıştırmak** için `fastapi` veya `uvicorn` komutlarıyla `--workers` CLI seçeneğini kullanarak birden fazla worker process çalıştırabilirsiniz.

-Diğer deployment kavramlarını da kendiniz ele alarak kendi deployment sisteminizi kuruyorsanız, bu araçları ve fikirleri kullanabilirsiniz.
+Diğer deployment kavramlarını da kendiniz ele alarak **kendi deployment sisteminizi** kuruyorsanız, bu araçları ve fikirleri kullanabilirsiniz.

-Container'larla (örn. Docker ve Kubernetes) FastAPI'yi öğrenmek için bir sonraki bölüme göz atın. Bu araçların, diğer deployment kavramlarını çözmek için de basit yöntemleri olduğunu göreceksiniz. ✨
+Container'larla (örn. Docker ve Kubernetes) **FastAPI**'yi öğrenmek için bir sonraki bölüme göz atın. Bu araçların, diğer **deployment kavramlarını** çözmek için de basit yöntemleri olduğunu göreceksiniz. ✨
@@ -1,298 +1,11 @@
 # Ortam Değişkenleri { #environment-variables }

-/// tip | İpucu
+**Ortam değişkeni** (**env var** olarak da bilinir), Python kodunuzun dışında, işletim sisteminde bulunan ve uygulamanız ile diğer programlar tarafından okunabilen bir değerdir.

-"Ortam değişkenleri"nin ne olduğunu ve nasıl kullanılacağını zaten biliyorsanız, bu bölümü atlayabilirsiniz.
+FastAPI uygulamaları; database URL'leri, email kimlik bilgileri ve secret key'ler gibi konfigürasyonlar için ortam değişkenlerini yaygın olarak kullanır.

-///
+Bunları uygulama konfigürasyonu için nasıl kullanacağınızı [Ayarlar ve Ortam Değişkenleri](advanced/settings.md) bölümünde öğreneceksiniz.

-Ortam değişkeni (genelde "**env var**" olarak da anılır), Python kodunun **dışında**, **işletim sistemi** seviyesinde bulunan ve Python kodunuz (veya diğer programlar) tarafından okunabilen bir değişkendir.
+## Daha Fazla Bilgi Edinin { #learn-more }

-Ortam değişkenleri; uygulama **ayarları**nı yönetmek, Python’un **kurulumu**nun bir parçası olarak konfigürasyon yapmak vb. durumlarda işe yarar.
-
-## Env Var Oluşturma ve Kullanma { #create-and-use-env-vars }
-
-Python’a ihtiyaç duymadan, **shell (terminal)** içinde ortam değişkenleri **oluşturabilir** ve kullanabilirsiniz:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// MY_NAME adlı bir env var'ı şöyle oluşturabilirsiniz
-$ export MY_NAME="Wade Wilson"
-
-// Sonra bunu diğer programlarla şöyle kullanabilirsiniz
-$ echo "Hello $MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// MY_NAME adlı bir env var oluşturun
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Bunu diğer programlarla şöyle kullanın
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-## Python’da Env Var Okuma { #read-env-vars-in-python }
-
-Ortam değişkenlerini Python’un **dışında** (terminalde veya başka bir yöntemle) oluşturup daha sonra **Python’da okuyabilirsiniz**.
-
-Örneğin `main.py` adında bir dosyanız şöyle olabilir:
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | İpucu
-
-[`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) fonksiyonunun ikinci argümanı, bulunamadığında döndürülecek varsayılan (default) değerdir.
-
-Verilmezse varsayılan olarak `None` olur; burada varsayılan değer olarak `"World"` verdik.
-
-///
-
-Sonrasında bu Python programını çalıştırabilirsiniz:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Burada env var'ı henüz ayarlamıyoruz
-$ python main.py
-
-// Env var'ı ayarlamadığımız için varsayılan değeri alırız
-
-Hello World from Python
-
-// Ama önce bir ortam değişkeni oluşturursak
-$ export MY_NAME="Wade Wilson"
-
-// Sonra programı tekrar çağırırsak
-$ python main.py
-
-// Artık ortam değişkenini okuyabilir
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Burada env var'ı henüz ayarlamıyoruz
-$ python main.py
-
-// Env var'ı ayarlamadığımız için varsayılan değeri alırız
-
-Hello World from Python
-
-// Ama önce bir ortam değişkeni oluşturursak
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Sonra programı tekrar çağırırsak
-$ python main.py
-
-// Artık ortam değişkenini okuyabilir
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-Ortam değişkenleri kodun dışında ayarlanabildiği, ama kod tarafından okunabildiği ve dosyalarla birlikte saklanmasının (ör. `git`’e commit edilmesinin) gerekmediği için, konfigürasyon veya **ayarlar** için sıkça kullanılır.
-
-Ayrıca, bir ortam değişkenini yalnızca **belirli bir program çalıştırımı** için oluşturabilirsiniz; bu değişken sadece o program tarafından, sadece o çalıştırma süresince kullanılabilir.
-
-Bunu yapmak için, program komutunun hemen öncesinde ve aynı satırda tanımlayın:
-
-<div class="termy">
-
-```console
-// Bu program çağrısı için aynı satırda MY_NAME adlı bir env var oluşturun
-$ MY_NAME="Wade Wilson" python main.py
-
-// Artık ortam değişkenini okuyabilir
-
-Hello Wade Wilson from Python
-
-// Sonrasında env var artık mevcut değildir
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
-/// tip | İpucu
-
-Bu konuyla ilgili daha fazlasını [Twelve-Factor Uygulaması: Config](https://12factor.net/config) bölümünde okuyabilirsiniz.
-
-///
-
-## Türler ve Doğrulama { #types-and-validation }
-
-Bu ortam değişkenleri yalnızca **metin string**’lerini taşıyabilir. Çünkü Python’un dışındadırlar ve diğer programlarla, sistemin geri kalanıyla (hatta Linux, Windows, macOS gibi farklı işletim sistemleriyle) uyumlu olmak zorundadırlar.
-
-Bu, Python’da bir ortam değişkeninden okunan **her değerin `str` olacağı** anlamına gelir. Farklı bir tipe dönüştürme veya doğrulama işlemleri kod içinde yapılmalıdır.
-
-Uygulama **ayarları**nı yönetmek için ortam değişkenlerini kullanmayı, [İleri Seviye Kullanıcı Rehberi - Ayarlar ve Ortam Değişkenleri](./advanced/settings.md) bölümünde daha detaylı öğreneceksiniz.
-
-## `PATH` Ortam Değişkeni { #path-environment-variable }
-
-İşletim sistemlerinin (Linux, macOS, Windows) çalıştırılacak programları bulmak için kullandığı **özel** bir ortam değişkeni vardır: **`PATH`**.
-
-`PATH` değişkeninin değeri uzun bir string’dir; Linux ve macOS’te dizinler iki nokta üst üste `:` ile, Windows’ta ise noktalı virgül `;` ile ayrılır.
-
-Örneğin `PATH` ortam değişkeni şöyle görünebilir:
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Bu, sistemin şu dizinlerde program araması gerektiği anlamına gelir:
-
-* `/usr/local/bin`
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
-```
-
-Bu, sistemin şu dizinlerde program araması gerektiği anlamına gelir:
-
-* `C:\Program Files\Python312\Scripts`
-* `C:\Program Files\Python312`
-* `C:\Windows\System32`
-
-////
-
-Terminalde bir **komut** yazdığınızda, işletim sistemi `PATH` ortam değişkeninde listelenen **bu dizinlerin her birinde** programı **arar**.
-
-Örneğin terminalde `python` yazdığınızda, işletim sistemi bu listedeki **ilk dizinde** `python` adlı bir program arar.
-
-Bulursa **onu kullanır**. Bulamazsa **diğer dizinlerde** aramaya devam eder.
-
-### Python Kurulumu ve `PATH`’in Güncellenmesi { #installing-python-and-updating-the-path }
-
-Python’u kurarken, `PATH` ortam değişkenini güncellemek isteyip istemediğiniz sorulabilir.
-
-//// tab | Linux, macOS
-
-Diyelim ki Python’u kurdunuz ve `/opt/custompython/bin` dizinine yüklendi.
-
-`PATH` ortam değişkenini güncellemeyi seçerseniz, kurulum aracı `/opt/custompython/bin` yolunu `PATH` ortam değişkenine ekler.
-
-Şöyle görünebilir:
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
-```
-
-Böylece terminalde `python` yazdığınızda, sistem `/opt/custompython/bin` (son dizin) içindeki Python programını bulur ve onu kullanır.
-
-////
-
-//// tab | Windows
-
-Diyelim ki Python’u kurdunuz ve `C:\opt\custompython\bin` dizinine yüklendi.
-
-`PATH` ortam değişkenini güncellemeyi seçerseniz, kurulum aracı `C:\opt\custompython\bin` yolunu `PATH` ortam değişkenine ekler.
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
-```
-
-Böylece terminalde `python` yazdığınızda, sistem `C:\opt\custompython\bin` (son dizin) içindeki Python programını bulur ve onu kullanır.
-
-////
-
-Yani şunu yazarsanız:
-
-<div class="termy">
-
-```console
-$ python
-```
-
-</div>
-
-//// tab | Linux, macOS
-
-Sistem `python` programını `/opt/custompython/bin` içinde **bulur** ve çalıştırır.
-
-Bu, kabaca şunu yazmaya denktir:
-
-<div class="termy">
-
-```console
-$ /opt/custompython/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows
-
-Sistem `python` programını `C:\opt\custompython\bin\python` içinde **bulur** ve çalıştırır.
-
-Bu, kabaca şunu yazmaya denktir:
-
-<div class="termy">
-
-```console
-$ C:\opt\custompython\bin\python
-```
-
-</div>
-
-////
-
-Bu bilgiler, [Sanal Ortamlar](virtual-environments.md) konusunu öğrenirken işinize yarayacak.
-
-## Sonuç { #conclusion }
-
-Buraya kadar **ortam değişkenleri**nin ne olduğuna ve Python’da nasıl kullanılacağına dair temel bir fikir edinmiş olmalısınız.
-
-Ayrıca [Ortam Değişkeni için Wikipedia](https://en.wikipedia.org/wiki/Environment_variable) sayfasından daha fazlasını da okuyabilirsiniz.
-
-Çoğu zaman ortam değişkenlerinin hemen nasıl işe yarayacağı ilk bakışta çok net olmayabilir. Ancak geliştirme yaparken birçok farklı senaryoda tekrar tekrar karşınıza çıkarlar; bu yüzden bunları bilmek faydalıdır.
-
-Örneğin bir sonraki bölümde, [Sanal Ortamlar](virtual-environments.md) konusunda bu bilgilere ihtiyaç duyacaksınız.
+Ortam değişkenlerini nasıl oluşturup okuyacağınızı ve `PATH` ortam değişkeninin nasıl çalıştığını da içeren detaylı, platformlar arası bir açıklama için [Ortam Değişkenleri rehberini](https://tiangolo.com/guides/environment-variables/) okuyun.
@@ -2,7 +2,7 @@

 **FastAPI <abbr title="command line interface - komut satırı arayüzü">CLI</abbr>**, FastAPI uygulamanızı servis etmek, FastAPI projenizi yönetmek ve daha fazlası için kullanabileceğiniz bir komut satırı programıdır.

-FastAPI'yi kurduğunuzda (ör. `pip install "fastapi[standard]"`), terminalde çalıştırabileceğiniz bir komut satırı programı birlikte gelir.
+FastAPI'yi projenize eklediğinizde (ör. `uv add "fastapi[standard]"` ile), terminalde çalıştırabileceğiniz bir komut satırı programı birlikte gelir.

 FastAPI uygulamanızı geliştirme için çalıştırmak üzere `fastapi dev` komutunu kullanabilirsiniz:

@@ -52,7 +52,7 @@ Production için `fastapi dev` yerine `fastapi run` kullanırsınız. 🚀

 ///

-İçeride, **FastAPI CLI**, yüksek performanslı, production'a hazır bir ASGI server olan [Uvicorn](https://www.uvicorn.dev)'u kullanır. 😎
+İçeride, **FastAPI CLI**, yüksek performanslı, production'a hazır bir ASGI server olan [Uvicorn](https://uvicorn.dev)'u kullanır. 😎

 `fastapi` CLI, çalıştırılacak FastAPI app'ini otomatik olarak tespit etmeye çalışır; `main.py` dosyasında `app` adlı bir nesne olduğunu varsayar (veya birkaç başka varyant).

@@ -95,21 +95,21 @@ Bu da şu koda eşdeğerdir:
 from backend.main import app
 ```

-### path veya `--entrypoint` CLI seçeneği ile `fastapi dev` { #fastapi-dev-with-path-or-with-entrypoint-cli-option }
+### path ile veya `--entrypoint` CLI seçeneği ile `fastapi dev` { #fastapi-dev-with-path-or-with-entrypoint-cli-option }

 Ayrıca `fastapi dev` komutuna dosya path'ini de verebilirsiniz; hangi FastAPI app nesnesinin kullanılacağını tahmin eder:

 ```console
-$ fastapi dev main.py
+$ uv run fastapi dev main.py
 ```

 Ya da `fastapi dev` komutuna `--entrypoint` seçeneğini de verebilirsiniz:

 ```console
-$ fastapi dev --entrypoint main:app
+$ uv run fastapi dev --entrypoint main:app
 ```

-Ancak `fastapi` komutunu her çağırdığınızda doğru path'i veya entrypoint'i geçmeyi hatırlamanız gerekir.
+Ancak `fastapi` komutunu her çağırdığınızda doğru path'i/entrypoint'i geçmeyi hatırlamanız gerekir.

 Ayrıca, [VS Code Extension](editor-support.md) veya [FastAPI Cloud](https://fastapicloud.com) gibi diğer araçlar da bunu bulamayabilir; bu yüzden `pyproject.toml` içindeki `entrypoint`'i kullanmanız önerilir.

@@ -119,9 +119,13 @@ Ayrıca, [VS Code Extension](editor-support.md) veya [FastAPI Cloud](https://fas

 Varsayılan olarak **auto-reload** etkindir; kodunuzda değişiklik yaptığınızda server'ı otomatik olarak yeniden yükler. Bu, kaynak tüketimi yüksek bir özelliktir ve kapalı olduğuna kıyasla daha az stabil olabilir. Sadece geliştirme sırasında kullanmalısınız. Ayrıca yalnızca `127.0.0.1` IP adresini dinler; bu, makinenizin sadece kendisiyle iletişim kurması için kullanılan IP'dir (`localhost`).

+App'inizi import etmeden önce `fastapi dev`, `FASTAPI_ENV` ortam değişkenini `development` olarak ayarlar. `FASTAPI_ENV` zaten ayarlanmışsa mevcut değeri korunur. Bu, app başlangıç kodunun geliştirme dostu davranış seçebilmesini sağlar ve aynı zamanda `staging` gibi app'e özel bir ortam sağlamanıza izin verir.
+
+Geleneksel `FASTAPI_ENV` değerleri `development` ve `production` şeklindedir. `fastapi run` şu anda `FASTAPI_ENV` değerini değiştirmez; bu yüzden app'inizin production modunu tespit etmesi gerekiyorsa bunu açıkça ayarlayın.
+
 ## `fastapi run` { #fastapi-run }

-`fastapi run` çalıştırmak, varsayılan olarak FastAPI'yi production modunda başlatır.
+`fastapi run` komutunu çalıştırmak, FastAPI'yi production modunda başlatır.

 Varsayılan olarak **auto-reload** kapalıdır. Ayrıca `0.0.0.0` IP adresini dinler; bu, kullanılabilir tüm IP adresleri anlamına gelir. Böylece makineyle iletişim kurabilen herkes tarafından genel erişime açık olur. Bu, normalde production'da çalıştırma şeklidir; örneğin bir container içinde.

@@ -19,7 +19,7 @@ Etkileşimli API dokümantasyonu ve keşif için web arayüzleri. Framework Open

 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)

-* [**ReDoc**](https://github.com/Rebilly/ReDoc) ile alternatif API dokümantasyonu.
+* [**ReDoc**](https://github.com/Redocly/redoc) ile alternatif API dokümantasyonu.

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)

@@ -159,7 +159,7 @@ Her entegrasyon (bağımlılıklar ile) o kadar basit olacak şekilde tasarlanm

 ## Starlette Özellikleri { #starlette-features }

-**FastAPI**, [**Starlette**](https://www.starlette.dev/) ile tamamen uyumludur (ve onun üzerine kuruludur). Dolayısıyla elinizdeki ek Starlette kodları da çalışır.
+**FastAPI**, [**Starlette**](https://starlette.dev/) ile tamamen uyumludur (ve onun üzerine kuruludur). Dolayısıyla elinizdeki ek Starlette kodları da çalışır.

 `FastAPI` aslında `Starlette`’in bir alt sınıfıdır. Starlette’i zaten biliyor veya kullanıyorsanız, işlevlerin çoğu aynı şekilde çalışır.

@@ -171,13 +171,13 @@ Her entegrasyon (bağımlılıklar ile) o kadar basit olacak şekilde tasarlanm
 * Başlatma ve kapatma olayları.
 * HTTPX üzerine kurulu test istemcisi.
 * **CORS**, GZip, Static Files, Streaming response’lar.
-* **Session** ve **Cookie** desteği.
+* **Session ve Cookie** desteği.
 * %100 test kapsayıcılığı.
 * %100 type annotated kod tabanı.

 ## Pydantic Özellikleri { #pydantic-features }

-**FastAPI**, [**Pydantic**](https://docs.pydantic.dev/) ile tamamen uyumludur (ve onun üzerine kuruludur). Dolayısıyla elinizdeki ek Pydantic kodları da çalışır.
+**FastAPI**, [**Pydantic**](https://pydantic.dev/docs/) ile tamamen uyumludur (ve onun üzerine kuruludur). Dolayısıyla elinizdeki ek Pydantic kodları da çalışır.

 Pydantic’e dayanan harici kütüphaneler de dâhildir; veritabanları için <abbr title="Object-Relational Mapper - Nesne-İlişkisel Eşleyici">ORM</abbr>’ler, <abbr title="Object-Document Mapper - Nesne-Belge Eşleyici">ODM</abbr>’ler gibi.

@@ -45,20 +45,6 @@ FastAPI ve friends hakkında paylaşacak haberlerim olduğunda duymak için, yaz
 * [**Bluesky**'de @tiangolo.com](https://bsky.app/profile/tiangolo.com)
 * [**LinkedIn**'de @tiangolo](https://www.linkedin.com/in/tiangolo/).

-## GitHub'da Sorularla Başkalarına Yardım Edin { #help-others-with-questions-in-github }
-
-[GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered) içindeki sorularda başkalarına yardımcı olmayı deneyebilirsiniz.
-
-Birçok durumda bu soruların cevabını zaten biliyor olabilirsiniz. 🤓
-
-Eğer insanların sorularına çok yardım ederseniz, resmi bir [FastAPI Expert](fastapi-people.md#fastapi-experts) olursunuz. 🎉
-
-Şunu unutmayın: en önemli nokta, nazik olmaya çalışmak. 🤗
-
-### Nasıl Yardım Edebilirsiniz { #how-to-help }
-
-[Nasıl yardım edileceğine dair rehberi](https://tiangolo.com/open-source/help/#help-others-with-questions-in-github) izleyin.
-
 ## Soru Sorun { #ask-questions }

 GitHub repository'sinde örneğin şunlar için [yeni bir soru oluşturabilirsiniz](https://github.com/fastapi/fastapi/discussions/new?category=questions):
@@ -68,7 +54,7 @@ GitHub repository'sinde örneğin şunlar için [yeni bir soru oluşturabilirsin

 ## Sohbete Katılın { #join-the-chat }

-👥 [Discord sohbet sunucusuna](https://discord.gg/VQjSZaeJmf) 👥 katılın ve FastAPI topluluğundaki diğer kişilerle takılın.
+👥 [Discord sohbet sunucusuna](https://discord.com/invite/VQjSZaeJmf) 👥 katılın ve FastAPI topluluğundaki diğer kişilerle takılın.

 /// tip | İpucu

@@ -85,3 +71,9 @@ Chat sistemleri daha "serbest sohbet"e izin verdiği için, çok genel ve yanıt
 GitHub'da şablon (template) doğru soruyu yazmanız için sizi yönlendirir; böylece daha kolay iyi bir cevap alabilir, hatta bazen sormadan önce problemi kendiniz çözebilirsiniz.

 Ayrıca chat sistemlerindeki konuşmalar GitHub kadar kolay aranabilir değildir; sohbet içinde kaybolurlar.
+
+## FastAPI Cloud'u Deneyin { #try-fastapi-cloud }
+
+FastAPI ve friends için ana finansman, FastAPI uygulamalarını tek bir komutla, `fastapi deploy`, basit ve hızlı bir şekilde deploy etmeye yarayan bir platform olan [**FastAPI Cloud**](https://fastapicloud.com)'dan gelir.
+
+FastAPI Cloud, FastAPI'nin arkasındaki aynı ekip tarafından geliştirilmektedir. Deneyebilir ve projeleriniz için değerlendirebilirsiniz.
@@ -54,11 +54,11 @@ Hepsi, tüm geliştiriciler için en iyi geliştirme deneyimini sağlayacak şek

 ## Gereksinimler { #requirements }

-Çeşitli alternatifleri test ettikten sonra, avantajlarından dolayı [**Pydantic**](https://docs.pydantic.dev/)'i kullanmaya karar verdim.
+Çeşitli alternatifleri test ettikten sonra, avantajlarından dolayı [**Pydantic**](https://pydantic.dev/docs/)'i kullanmaya karar verdim.

 Sonra, JSON Schema ile tamamen uyumlu olmasını sağlamak, kısıtlama bildirimlerini tanımlamanın farklı yollarını desteklemek ve birkaç editördeki testlere dayanarak editör desteğini (tip kontrolleri, otomatik tamamlama) geliştirmek için katkıda bulundum.

-Geliştirme sırasında, diğer ana gereksinim olan [**Starlette**](https://www.starlette.dev/)'e de katkıda bulundum.
+Geliştirme sırasında, diğer ana gereksinim olan [**Starlette**](https://starlette.dev/)'e de katkıda bulundum.

 ## Geliştirme { #development }

@@ -70,7 +70,7 @@ Geliştirme sırasında, diğer ana gereksinim olan [**Starlette**](https://www.

 Birçok kullanım durumuna daha iyi uyduğu için, önceki alternatiflerin yerine seçiliyor.

-Ben ve ekibim dahil, birçok geliştirici ve ekip projelerinde **FastAPI**'ya bağlı.
+Ben ve ekibim dahil, birçok geliştirici ve ekip projelerinde **FastAPI**'a bağlı.

 Tabi, geliştirilecek birçok özellik ve iyileştirme mevcut.

@@ -67,7 +67,7 @@ Bir `Request` ayrıca `request.receive` içerir; bu, request'in body'sini "almak

 Ve bu iki şey, `scope` ve `receive`, yeni bir `Request` instance'ı oluşturmak için gerekenlerdir.

-`Request` hakkında daha fazla bilgi için [Starlette'ın Request dokümantasyonu](https://www.starlette.dev/requests/) bölümüne bakın.
+`Request` hakkında daha fazla bilgi için [Starlette'ın Request dokümantasyonu](https://starlette.dev/requests/) bölümüne bakın.

 ///

@@ -35,7 +35,7 @@ Yine de `app.routes`'i `get_openapi()`'ye geçebilirsiniz. FastAPI, etkili path

 ///

-/// note | Bilgi
+/// note | Not

 `summary` parametresi OpenAPI 3.1.0 ve üzeri sürümlerde vardır; FastAPI 0.99.0 ve üzeri tarafından desteklenmektedir.

@@ -45,7 +45,7 @@ Yine de `app.routes`'i `get_openapi()`'ye geçebilirsiniz. FastAPI, etkili path

 Yukarıdaki bilgileri kullanarak aynı yardımcı fonksiyonla OpenAPI şemasını üretebilir ve ihtiyacınız olan her parçayı override edebilirsiniz.

-Örneğin, [özel bir logo eklemek için ReDoc'un OpenAPI extension'ını](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo) ekleyelim.
+Örneğin, [özel bir logo eklemek için ReDoc'un OpenAPI extension'ını](https://github.com/Redocly/redoc/blob/main/docs/redoc-vendor-extensions.md#x-logo) ekleyelim.

 ### Normal **FastAPI** { #normal-fastapi }

@@ -1,6 +1,5 @@
 # GraphQL { #graphql }

-
 **FastAPI**, **ASGI** standardını temel aldığı için ASGI ile uyumlu herhangi bir **GraphQL** kütüphanesini entegre etmek oldukça kolaydır.

 Aynı uygulama içinde normal FastAPI *path operation*'larını GraphQL ile birlikte kullanabilirsiniz.
@@ -22,7 +21,7 @@ Aşağıda **ASGI** desteği olan bazı **GraphQL** kütüphaneleri var. Bunlar
 * [Strawberry](https://strawberry.rocks/) 🍓
    * [FastAPI dokümantasyonu](https://strawberry.rocks/docs/integrations/fastapi) ile
 * [Ariadne](https://ariadnegraphql.org/)
-    * [FastAPI dokümantasyonu](https://ariadnegraphql.org/docs/fastapi-integration) ile
+    * [FastAPI dokümantasyonu](https://ariadnegraphql.org/server/Integrations/fastapi-integration) ile
 * [Tartiflette](https://tartiflette.io/)
    * ASGI entegrasyonu sağlamak için [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) ile
 * [Graphene](https://graphene-python.org/)
@@ -24,7 +24,7 @@ Pydantic v1 kullanan eski bir FastAPI uygulamanız varsa, burada onu Pydantic v2

 ## Resmi Kılavuz { #official-guide }

-Pydantic'in v1'den v2'ye resmi bir [Migration Guide](https://docs.pydantic.dev/latest/migration/)'ı vardır.
+Pydantic'in v1'den v2'ye resmi bir [Geçiş Kılavuzu](https://pydantic.dev/docs/validation/latest/get-started/migration/) vardır.

 Ayrıca nelerin değiştiğini, validasyonların artık nasıl daha doğru ve katı olduğunu, olası dikkat edilmesi gereken noktaları (caveat) vb. de içerir.

@@ -26,7 +26,7 @@ include_yaml:
    <img src="https://img.shields.io/pypi/v/fastapi?color=%2334D058&label=pypi%20package" alt="Package version">
 </a>
 <a href="https://pypi.org/project/fastapi">
-    <img src="https://img.shields.io/pyp/pyversions/fastapi.svg?color=%2334D058" alt="Supported Python versions">
+    <img src="https://img.shields.io/pypi/pyversions/fastapi.svg?color=%2334D058" alt="Supported Python versions">
 </a>
 </p>

@@ -110,7 +110,7 @@ Temel özellikleri şunlardır:
  </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> kütüphanesini, sorgulanarak <strong>tahminler</strong> alınabilecek bir <strong>REST</strong> server başlatmak için benimsedik." <em>[Ludwig için]</em></blockquote>
-    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/">(ref)</a></div>
+    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/">(ref)</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> olarak <strong>kriz yönetimi</strong> orkestrasyon framework'ümüzün açık kaynak sürümünü duyurmaktan memnuniyet duyuyoruz: <strong>Dispatch</strong>!" <em>[FastAPI ile geliştirildi]</em></blockquote>
@@ -133,7 +133,7 @@ Temel özellikleri şunlardır:

 "_**FastAPI** kütüphanesini, **predictions** almak için sorgulanabilecek bir **REST** server oluşturmak amacıyla benimsedik. [Ludwig için]_"

-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/"><small>(ref)</small></a></div>

 ---

@@ -151,12 +151,6 @@ Temel özellikleri şunlardır:

 </div>

-## FastAPI Conf { #fastapi-conf }
-
-[**FastAPI Conf '26**](https://fastapiconf.com) **28 Ekim 2026**'da **Amsterdam, NL**'de gerçekleşiyor. Kaynağından, bütünüyle 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 Ekim 2026 - Amsterdam, NL"></a>
-
 ## FastAPI mini belgeseli { #fastapi-mini-documentary }

 2025'in sonunda yayınlanan bir [FastAPI mini belgeseli](https://www.youtube.com/watch?v=mpR8ngthqiE) var, online olarak izleyebilirsiniz:
@@ -175,17 +169,17 @@ Web API yerine terminalde kullanılacak bir <abbr title="Command Line Interface

 FastAPI iki devin omuzları üstünde duruyor:

-* Web kısımları için [Starlette](https://www.starlette.dev/).
-* Data kısımları için [Pydantic](https://docs.pydantic.dev/).
+* Web kısımları için [Starlette](https://starlette.dev/).
+* Data kısımları için [Pydantic](https://pydantic.dev/docs/).

 ## Kurulum { #installation }

-Bir [virtual environment](https://fastapi.tiangolo.com/tr/virtual-environments/) oluşturup etkinleştirelim ve ardından FastAPI'ı yükleyelim:
+Önce [`uv`'yi kurun](https://docs.astral.sh/uv/getting-started/installation/), ardından projenize FastAPI'ı ekleyin:

 <div class="termy">

 ```console
-$ pip install "fastapi[standard]"
+$ uv add "fastapi[standard]"

 ---> 100%
 ```
@@ -194,6 +188,8 @@ $ pip install "fastapi[standard]"

 **Not**: Tüm terminallerde çalıştığından emin olmak için `"fastapi[standard]"` ifadesini tırnak içinde yazdığınızdan emin olun.

+`pip` kullanmayı tercih ediyorsanız, `fastapi[standard]` paketini bir virtual environment içinde kurun. Alternatif adımlar için [kurulum rehberine](tutorial/#install-fastapi) bakın.
+
 ## Örnek { #example }

 ### Oluşturalım { #create-it }
@@ -250,7 +246,7 @@ Sunucuyu şu komutla çalıştıralım:
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
@@ -277,7 +273,7 @@ INFO:     Application startup complete.
 <details markdown="1">
 <summary><code>fastapi dev</code> komutu hakkında...</summary>

-`fastapi dev` komutu, `main.py` dosyanızı okur, içindeki **FastAPI** uygulamasını algılar ve [Uvicorn](https://www.uvicorn.dev) kullanarak bir server başlatır.
+`fastapi dev` komutu, `main.py` dosyanızı okur, içindeki **FastAPI** uygulamasını algılar ve [Uvicorn](https://uvicorn.dev) kullanarak bir server başlatır.

 Varsayılan olarak `fastapi dev`, local geliştirme için auto-reload etkin şekilde başlar.

@@ -314,7 +310,7 @@ Otomatik etkileşimli API dokümantasyonunu göreceksiniz ([Swagger UI](https://

 Ve şimdi [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) adresine gidin.

-Alternatif otomatik dokümantasyonu göreceksiniz ([ReDoc](https://github.com/Rebilly/ReDoc) tarafından sağlanır):
+Alternatif otomatik dokümantasyonu göreceksiniz ([ReDoc](https://github.com/Redocly/redoc) tarafından sağlanır):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -492,12 +488,12 @@ Daha fazla özellik içeren daha kapsamlı bir örnek için <a href="https://fas

 ### Uygulamanızı deploy edin (opsiyonel) { #deploy-your-app-optional }

-FastAPI uygulamanızı tek bir komutla [FastAPI Cloud](https://fastapicloud.com)'a deploy edebilirsiniz. 🚀
+FastAPI uygulamanızı isteğe bağlı olarak tek bir komutla [FastAPI Cloud](https://fastapicloud.com)'a deploy edebilirsiniz. 🚀

 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -540,7 +536,7 @@ FastAPI, Pydantic ve Starlette'a bağımlıdır.

 ### `standard` Bağımlılıkları { #standard-dependencies }

-FastAPI'ı `pip install "fastapi[standard]"` ile yüklediğinizde, opsiyonel bağımlılıkların `standard` grubuyla birlikte gelir:
+FastAPI'ı `uv add "fastapi[standard]"` ile yüklediğinizde, opsiyonel bağımlılıkların `standard` grubuyla birlikte gelir:

 Pydantic tarafından kullanılanlar:

@@ -554,17 +550,17 @@ Starlette tarafından kullanılanlar:

 FastAPI tarafından kullanılanlar:

-* [`uvicorn`](https://www.uvicorn.dev) - uygulamanızı yükleyen ve servis eden server için. Buna, yüksek performanslı servis için gereken bazı bağımlılıkları (örn. `uvloop`) içeren `uvicorn[standard]` dahildir.
+* [`uvicorn`](https://uvicorn.dev) - uygulamanızı yükleyen ve servis eden server için. Buna, yüksek performanslı servis için gereken bazı bağımlılıkları (örn. `uvloop`) içeren `uvicorn[standard]` dahildir.
 * `fastapi-cli[standard]` - `fastapi` komutunu sağlamak için.
    * Buna, FastAPI uygulamanızı [FastAPI Cloud](https://fastapicloud.com)'a deploy etmenizi sağlayan `fastapi-cloud-cli` dahildir.

 ### `standard` Bağımlılıkları Olmadan { #without-standard-dependencies }

-`standard` opsiyonel bağımlılıklarını dahil etmek istemiyorsanız, `pip install fastapi` ile kurabilirsiniz.
+`standard` opsiyonel bağımlılıklarını dahil etmek istemiyorsanız, `uv add "fastapi[standard]"` yerine `uv add fastapi` ile kurabilirsiniz.

 ### `fastapi-cloud-cli` Olmadan { #without-fastapi-cloud-cli }

-FastAPI'ı standard bağımlılıklarla ama `fastapi-cloud-cli` olmadan kurmak istiyorsanız, `pip install "fastapi[standard-no-fastapi-cloud-cli]"` ile yükleyebilirsiniz.
+FastAPI'ı standard bağımlılıklarla ama `fastapi-cloud-cli` olmadan kurmak istiyorsanız, `uv add "fastapi[standard-no-fastapi-cloud-cli]"` ile yükleyebilirsiniz.

 ### Ek Opsiyonel Bağımlılıklar { #additional-optional-dependencies }

@@ -572,13 +568,13 @@ Yüklemek isteyebileceğiniz bazı ek bağımlılıklar da vardır.

 Ek opsiyonel Pydantic bağımlılıkları:

-* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - ayar yönetimi için.
-* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - Pydantic ile kullanılacak ek type'lar için.
+* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) - ayar yönetimi için.
+* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) - Pydantic ile kullanılacak ek type'lar için.

 Ek opsiyonel FastAPI bağımlılıkları:

 * [`orjson`](https://github.com/ijl/orjson) - `ORJSONResponse` kullanmak istiyorsanız gereklidir.
-* [`ujson`](https://github.com/esnme/ultrajson) - `UJSONResponse` kullanmak istiyorsanız gereklidir.
+* [`ujson`](https://github.com/ultrajson/ultrajson) - `UJSONResponse` kullanmak istiyorsanız gereklidir.

 ## Lisans { #license }

@@ -1,17 +1,16 @@
 # Full Stack FastAPI Şablonu { #full-stack-fastapi-template }

-
 Şablonlar genellikle belirli bir kurulumla gelir, ancak esnek ve özelleştirilebilir olacak şekilde tasarlanırlar. Bu sayede şablonu projenizin gereksinimlerine göre değiştirip uyarlayabilir, çok iyi bir başlangıç noktası olarak kullanabilirsiniz. 🏁

 Bu şablonu başlangıç için kullanabilirsiniz; çünkü ilk kurulumun, güvenliğin, veritabanının ve bazı API endpoint'lerinin önemli bir kısmı sizin için zaten hazırlanmıştır.

-GitHub Repository: [Full Stack FastAPI Şablonu](https://github.com/tiangolo/full-stack-fastapi-template)
+GitHub Repository: [Full Stack FastAPI Şablonu](https://github.com/fastapi/full-stack-fastapi-template)

 ## Full Stack FastAPI Şablonu - Teknoloji Yığını ve Özellikler { #full-stack-fastapi-template-technology-stack-and-features }

 - ⚡ Python backend API için [**FastAPI**](https://fastapi.tiangolo.com/tr).
  - 🧰 Python SQL veritabanı etkileşimleri (ORM) için [SQLModel](https://sqlmodel.tiangolo.com).
-  - 🔍 FastAPI'nin kullandığı; veri doğrulama ve ayarlar yönetimi için [Pydantic](https://docs.pydantic.dev).
+  - 🔍 FastAPI'nin kullandığı; veri doğrulama ve ayarlar yönetimi için [Pydantic](https://pydantic.dev/docs/).
  - 💾 SQL veritabanı olarak [PostgreSQL](https://www.postgresql.org).
 - 🚀 frontend için [React](https://react.dev).
  - 💃 TypeScript, hooks, Vite ve modern bir frontend stack'inin diğer parçalarını kullanır.
@@ -270,7 +270,7 @@ Bunun "`one_person`, `Person` sınıfının bir **instance**'ıdır" anlamına g

 ## Pydantic modelleri { #pydantic-models }

-[Pydantic](https://docs.pydantic.dev/), data validation yapmak için bir Python kütüphanesidir.
+[Pydantic](https://pydantic.dev/docs/) is a Python kütüphanesidir.

 Verinin "shape"'ini attribute'lara sahip sınıflar olarak tanımlarsınız.

@@ -286,7 +286,7 @@ Resmî Pydantic dokümanlarından bir örnek:

 /// note | Not

-Daha fazlasını öğrenmek için [Pydantic'in dokümanlarına bakın](https://docs.pydantic.dev/).
+Daha fazlasını öğrenmek için [Pydantic'in dokümanlarına bakın](https://pydantic.dev/docs/).

 ///

@@ -51,8 +51,10 @@ Ve yazma işlemi `async` ve `await` kullanmadığı için fonksiyonu normal `def

 **FastAPI** her durumda ne yapılacağını ve aynı objenin nasıl yeniden kullanılacağını bilir; böylece tüm arka plan görevleri birleştirilir ve sonrasında arka planda çalıştırılır:

+
 {* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}

+
 Bu örnekte, response gönderildikten *sonra* mesajlar `log.txt` dosyasına yazılacaktır.

 Request’te bir query varsa, log’a bir arka plan göreviyle yazılır.
@@ -61,7 +63,7 @@ Ardından *path operation function* içinde oluşturulan başka bir arka plan g

 ## Teknik Detaylar { #technical-details }

-`BackgroundTasks` sınıfı doğrudan [`starlette.background`](https://www.starlette.dev/background/)’dan gelir.
+`BackgroundTasks` sınıfı doğrudan [`starlette.background`](https://starlette.dev/background/)’dan gelir.

 `fastapi` üzerinden import edebilmeniz ve yanlışlıkla `starlette.background` içindeki alternatif `BackgroundTask`’i (sonunda `s` olmadan) import etmemeniz için FastAPI’nin içine doğrudan import/eklenmiştir.

@@ -69,7 +71,7 @@ Sadece `BackgroundTasks` (ve `BackgroundTask` değil) kullanarak, bunu bir *path

 FastAPI’de `BackgroundTask`’i tek başına kullanmak hâlâ mümkündür; ancak bu durumda objeyi kendi kodunuzda oluşturmanız ve onu içeren bir Starlette `Response` döndürmeniz gerekir.

-Daha fazla detayı [Starlette’in Background Tasks için resmi dokümantasyonunda](https://www.starlette.dev/background/) görebilirsiniz.
+Daha fazla detayı [Starlette’in Background Tasks için resmi dokümantasyonunda](https://starlette.dev/background/) görebilirsiniz.

 ## Dikkat Edilmesi Gerekenler { #caveat }

@@ -453,7 +453,7 @@ ve `app.include_router()` ile eklenen diğer tüm *path operation*’larla birli

 /// note | Çok Teknik Detaylar

-Not: Bu, muhtemelen doğrudan atlayabileceğiniz oldukça teknik bir detaydır.
+**Not**: Bu, muhtemelen **doğrudan atlayabileceğiniz** oldukça teknik bir detaydır.

 ---

@@ -461,7 +461,7 @@ Not: Bu, muhtemelen doğrudan atlayabileceğiniz oldukça teknik bir detaydır.

 Bunun nedeni, onların *path operation*’larını OpenAPI şemasına ve kullanıcı arayüzlerine dahil etmek istememizdir.

-FastAPI, orijinal router’ları ve *path operation*’ları etkin tutar; istekleri işlerken ve OpenAPI üretirken router prefix’lerini, dependency’leri, tag’leri, responses’ları ve diğer metaverileri birleştirir.
+FastAPI, orijinal router’ları ve *path operation*’ları etkin tutar; request'leri işlerken ve OpenAPI üretirken router prefix’lerini, dependency’leri, tag’leri, response’ları ve diğer metaverileri birleştirir.

 ///

@@ -487,7 +487,7 @@ Böylece `fastapi` komutu uygulamanızı nerede bulacağını bilir.
 Komuta dosya yolunu da verebilirsiniz, örneğin:

 ```console
-$ fastapi dev app/main.py
+$ uv run fastapi dev app/main.py
 ```

 Ancak o zaman her `fastapi` komutunu çalıştırdığınızda doğru yolu hatırlayıp geçirmeniz gerekir.
@@ -503,7 +503,7 @@ Ayrıca, diğer araçlar uygulamayı bulamayabilir; örneğin [VS Code Eklentisi
 <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)
 ```
@@ -96,7 +96,7 @@ Yine, sadece bu tanımı yaparak **FastAPI** ile şunları elde edersiniz:

 `str`, `int`, `float` vb. normal tekil tiplerin yanında, `str`’den türeyen daha karmaşık tekil tipleri de kullanabilirsiniz.

-Tüm seçenekleri görmek için [Pydantic Türlerine Genel Bakış](https://docs.pydantic.dev/latest/concepts/types/) sayfasına göz atın. Sonraki bölümde bazı örnekleri göreceksiniz.
+Tüm seçenekleri görmek için [Pydantic Türlerine Genel Bakış](https://pydantic.dev/docs/validation/latest/concepts/types/) sayfasına göz atın. Sonraki bölümde bazı örnekleri göreceksiniz.

 Örneğin `Image` modelinde bir `url` alanımız olduğuna göre, bunu `str` yerine Pydantic’in `HttpUrl` tipinden bir instance olacak şekilde tanımlayabiliriz:

@@ -150,7 +150,7 @@ Bu, aşağıdaki gibi bir JSON body bekler (dönüştürür, doğrular, doküman

 /// note | Not

-`Offer`’ın bir `Item` list’i olduğuna, `Item`’ların da opsiyonel bir `Image` list’ine sahip olduğuna dikkat edin.
+`Offer`’ın bir `Item` list’i olduğuna, `Item`’ların da opsiyonel bir `Image` list’ine sahip olduğuna dikkat edin

 ///

@@ -7,7 +7,7 @@ Bir **request** body, client'in API'nize gönderdiği veridir. Bir **response**

 API'niz neredeyse her zaman bir **response** body göndermek zorundadır. Ancak client'lerin her zaman **request body** göndermesi gerekmez; bazen sadece bir path isterler, belki birkaç query parametresiyle birlikte, ama body göndermezler.

-Bir **request** body tanımlamak için, tüm gücü ve avantajlarıyla [Pydantic](https://docs.pydantic.dev/) modellerini kullanırsınız.
+Bir **request** body tanımlamak için, tüm gücü ve avantajlarıyla [Pydantic](https://pydantic.dev/docs/) modellerini kullanırsınız.

 /// note | Not

@@ -15,7 +15,7 @@ FastAPI uygulamanızda `uvicorn`'ı import edip doğrudan çalıştırın:
 <div class="termy">

 ```console
-$ python myapp.py
+$ uv run python myapp.py
 ```

 </div>
@@ -35,7 +35,7 @@ Dosyanızın adının `myapp.py` olduğunu varsayalım.
 <div class="termy">

 ```console
-$ python myapp.py
+$ uv run python myapp.py
 ```

 </div>
@@ -36,7 +36,7 @@ Kullanabileceğiniz ek veri tiplerinden bazıları şunlardır:
 * `datetime.timedelta`:
    * Python `datetime.timedelta`.
    * request'lerde ve response'larda toplam saniye sayısını ifade eden bir `float` olarak temsil edilir.
-    * Pydantic, bunu ayrıca bir "ISO 8601 time diff encoding" olarak temsil etmeye de izin verir, [daha fazla bilgi için dokümanlara bakın](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
+    * Pydantic, bunu ayrıca bir "ISO 8601 time diff encoding" olarak temsil etmeye de izin verir, [daha fazla bilgi için dokümanlara bakın](https://pydantic.dev/docs/validation/latest/concepts/serialization/#custom-serializers).
 * `frozenset`:
    * request'lerde ve response'larda, `set` ile aynı şekilde ele alınır:
        * request'lerde bir list okunur, tekrarlar kaldırılır ve `set`'e dönüştürülür.
@@ -49,11 +49,11 @@ Kullanabileceğiniz ek veri tiplerinden bazıları şunlardır:
 * `Decimal`:
    * Standart Python `Decimal`.
    * request'lerde ve response'larda `float` ile aynı şekilde işlenir.
-* Geçerli tüm Pydantic veri tiplerini burada görebilirsiniz: [Pydantic veri tipleri](https://docs.pydantic.dev/latest/usage/types/types/).
+* Geçerli tüm Pydantic veri tiplerini burada görebilirsiniz: [Pydantic veri tipleri](https://pydantic.dev/docs/validation/latest/concepts/types/).

 ## Örnek { #example }

-Yukarıdaki tiplerden bazılarını kullanan parametrelere sahip bir örnek *path operation*:
+Yukarıdaki tiplerden bazılarını kullanan parametrelere sahip bir örnek *path operation*.

 {* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}

@@ -167,7 +167,7 @@ Bunu yapmak için standart Python type hint'i olan [`typing.Union`](https://docs

 /// note | Not

-Bir [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions) tanımlarken en spesifik type'ı önce, daha az spesifik olanı sonra ekleyin. Aşağıdaki örnekte daha spesifik olan `PlaneItem`, `Union[PlaneItem, CarItem]` içinde `CarItem`'dan önce gelir.
+Bir [`Union`](https://pydantic.dev/docs/validation/latest/concepts/unions/) tanımlarken en spesifik type'ı önce, daha az spesifik olanı sonra ekleyin. Aşağıdaki örnekte daha spesifik olan `PlaneItem`, `Union[PlaneItem, CarItem]` içinde `CarItem`'dan önce gelir.

 ///

@@ -209,4 +209,4 @@ Bu durumda `dict` kullanabilirsiniz:

 Her duruma göre birden fazla Pydantic modeli kullanın ve gerekirse özgürce inheritance uygulayın.

-Bir entity'nin farklı "state"lere sahip olması gerekiyorsa, o entity için tek bir veri modeli kullanmak zorunda değilsiniz. Örneğin `password` içeren, `password_hash` içeren ve `password` içermeyen state'lere sahip kullanıcı "entity"si gibi.
+Bir entity'nin farklı "state"lere sahip olması gerekiyorsa, o entity için tek bir veri modeli kullanmak zorunda değilsiniz. **user** "entity"si buna örnektir; `password`, `password_hash` içeren veya password içermeyen state'lere sahip olabilir.
@@ -7,12 +7,18 @@ En sade FastAPI dosyası şu şekilde görünür:

 Yukarıdakini `main.py` adlı bir dosyaya kopyalayın.

+/// tip | İpucu
+
+FastAPI'nin [VS Code için resmi bir eklentisi](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (ve Cursor için) vardır; path operation explorer, path operation search, testlerde CodeLens navigasyonu (testlerden tanıma atlama), FastAPI Cloud deployment ve log'lar dahil olmak üzere birçok özelliği doğrudan editörünüzden sağlar.
+
+///
+
 Canlı sunucuyu çalıştırın:

 <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 🚀

@@ -79,7 +85,7 @@ Otomatik etkileşimli API dokümantasyonunu ([Swagger UI](https://github.com/swa

 Ve şimdi [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) adresine gidin.

-Alternatif otomatik dokümantasyonu ([ReDoc](https://github.com/Rebilly/ReDoc) tarafından sağlanan) göreceksiniz:
+Alternatif otomatik dokümantasyonu ([ReDoc](https://github.com/Redocly/redoc) tarafından sağlanan) göreceksiniz:

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -186,16 +192,16 @@ from backend.main import app
 Dosya path'ini `fastapi dev` komutuna da verebilirsiniz; hangi FastAPI app objesini kullanacağını tahmin eder:

 ```console
-$ fastapi dev main.py
+$ uv run fastapi dev main.py
 ```

 Veya `fastapi dev` komutuna `--entrypoint` seçeneğini de geçebilirsiniz:

 ```console
-$ fastapi dev --entrypoint main:app
+$ uv run fastapi dev --entrypoint main:app
 ```

-Ancak `fastapi` komutunu her çağırdığınızda doğru path'i veya entrypoint'i geçmeyi hatırlamanız gerekir.
+Ancak `fastapi` komutunu her çağırdığınızda doğru path'i/entrypoint'i geçmeyi hatırlamanız gerekir.

 Ayrıca, [VS Code Eklentisi](../editor-support.md) veya [FastAPI Cloud](https://fastapicloud.com) gibi başka araçlar da onu bulamayabilir; bu yüzden `pyproject.toml` içindeki `entrypoint`'i kullanmanız önerilir.

@@ -206,7 +212,7 @@ Ayrıca, [VS Code Eklentisi](../editor-support.md) veya [FastAPI Cloud](https://
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -233,7 +239,7 @@ Bu kadar! Artık uygulamanıza o URL üzerinden erişebilirsiniz. ✨

 `FastAPI`, doğrudan `Starlette`'ten miras alan bir class'tır.

-[Starlette](https://www.starlette.dev/)'in tüm işlevselliğini `FastAPI` ile de kullanabilirsiniz.
+[Starlette](https://starlette.dev/)'in tüm işlevselliğini `FastAPI` ile de kullanabilirsiniz.

 ///

@@ -52,7 +52,7 @@ Bunun için `fallback="index.html"` kullanın:

 {* ../../docs_src/frontend/tutorial002_py310.py hl[5] *}

-**FastAPI** bu fallback'i yalnızca tarayıcı gezinmesi gibi görünen `GET` ve `HEAD` request'leri için kullanır. JavaScript, CSS ve görseller gibi eksik dosyalar yine `404` döndürür.
+**FastAPI** bu fallback'i yalnızca, tarayıcı gezinme request'lerinin normalde yaptığı gibi `Accept: text/html` veya `Accept: application/xhtml+xml` ile HTML'i açıkça kabul eden `GET` ve `HEAD` request'leri için kullanır. JavaScript, CSS ve görseller gibi eksik dosyalar yine `404` döndürür.

 `POST` veya `PUT` gibi diğer metotlarla, yalnızca frontend fallback'i ile eşleşen path'lere yapılan request'ler de `404` döndürür. Normal **FastAPI** *path operation*'ları frontend route'larından yine daha yüksek önceliğe sahiptir.

@@ -106,9 +106,13 @@ Bundan sonra bulunamayan frontend path'leri normal `404` döndürür.

 ## Dizini Kontrol Etme { #check-directory }

-Varsayılan olarak `app.frontend()`, uygulama oluşturulduğunda dizinin var olduğunu kontrol eder.
+Varsayılan olarak `app.frontend()`, `check_dir="auto"` kullanır.

-Bu, yapılandırma hatalarını erken yakalamaya yardımcı olur. Örneğin frontend build çıktısı dizini yoksa, **FastAPI** başlangıçta hata verir.
+`FASTAPI_ENV` ortam değişkeni `development` olarak ayarlandığında, frontend build çıktısı dizini eksikse **FastAPI** yalnızca bir uyarı gösterir. [`fastapi dev` komutu](https://github.com/fastapi/fastapi-cli#fastapi-dev), bu ortam değişkeni zaten ayarlı değilse sizin için ayarlar. Bu, development sırasında frontend'i build etmeden veya başlatmadan önce backend'i başlatmanıza olanak tanır.
+
+Diğer tüm ortamlarda, app oluşturulduğunda **FastAPI** bir hata verir. Bu, frontend dosyaları olmadan bir app deploy etmeden önce yapılandırma hatalarını erken yakalamaya yardımcı olur.
+
+App oluşturulduğunda dizini her zaman kontrol etmek için `check_dir=True` de ayarlayabilirsiniz.

 Frontend dosyalarınız daha sonra oluşturuluyorsa, örneğin app nesnesi oluşturulduktan sonra ayrı bir build adımıyla, `check_dir=False` ayarlayın:

@@ -132,6 +136,8 @@ Frontend response'ları normal **FastAPI** uygulaması içinde çalışır, bu y

 Uygulamadan, bir `APIRouter`'dan ve `include_router()`'dan gelen dependencies de frontend response'larına uygulanır. Bu, bir frontend'i cookie authentication veya benzeri bir yöntemle korumak için kullanışlı olabilir.

+Dependencies, normal *path operation*'larda olduğu gibi response header'larını değiştirebilir ve background task'lar ekleyebilir.
+
 ## Yalnızca Statik Build Çıktısı { #static-build-output-only }

 `app.frontend()`, frontend build'iniz tarafından önceden oluşturulmuş dosyaları sunar.
@@ -81,7 +81,7 @@ Ama ileri seviye bir senaryo için ihtiyaç duyarsanız, özel header’lar ekle

 ## Özel Exception Handler’ları Kurmak { #install-custom-exception-handlers }

-[Starlette’in aynı exception yardımcı araçlarıyla](https://www.starlette.dev/exceptions/) özel exception handler’lar ekleyebilirsiniz.
+[Starlette’in aynı exception yardımcı araçlarıyla](https://starlette.dev/exceptions/) özel exception handler’lar ekleyebilirsiniz.

 Diyelim ki sizin (ya da kullandığınız bir kütüphanenin) `raise` edebileceği `UnicornException` adında özel bir exception’ınız var.

@@ -10,12 +10,12 @@ Ayrıca, ileride tekrar dönüp tam olarak ihtiyaç duyduğunuz şeyi görebilec

 Tüm code block'lar kopyalanıp doğrudan kullanılabilir (zaten test edilmiş Python dosyalarıdır).

-Örneklerden herhangi birini çalıştırmak için, kodu `main.py` adlı bir dosyaya kopyalayın ve `fastapi dev`'i başlatın:
+Örneklerden herhangi birini çalıştırmak için, kodu `main.py` adlı bir dosyaya kopyalayın ve `uv run` ile `fastapi dev`'i başlatın:

 <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 @@ Editörünüzde kullanmak FastAPI'nin avantajlarını gerçekten gösterir: ne k

 ## FastAPI'yi Kurun { #install-fastapi }

-İlk adım FastAPI'yi kurmaktır.
+İlk adım projenizi hazırlamak ve FastAPI'yi eklemektir.

-Bir [sanal ortam](../virtual-environments.md) oluşturduğunuzdan emin olun, etkinleştirin ve ardından **FastAPI'yi kurun**:
+[`uv`](https://docs.astral.sh/uv/getting-started/installation/)'yi kurun, ardından bir proje oluşturup FastAPI'yi ekleyin:

 <div class="termy">

 ```console
-$ pip install "fastapi[standard]"
+$ uv init awesome-project --bare
+$ cd awesome-project
+$ uv add "fastapi[standard]"

 ---> 100%
 ```

 </div>

+`uv add`, projenin sanal ortamını `.venv` içinde oluşturur, FastAPI'yi `pyproject.toml` dosyasına ekler ve aynı paket sürümlerinin daha sonra kurulabilmesi için `uv.lock` oluşturur.
+
+/// details | Bu komutlar ne yapar
+
+* `uv init`: yeni bir Python projesi oluşturur.
+* `awesome-project`: projeyi bu adla yeni bir dizinde oluşturur.
+* `--bare`: örnek bir `main.py`, `README.md` veya başka dosyalar oluşturmadan yalnızca en minimal `pyproject.toml` dosyasını oluşturur. Bu eğitimin sonraki adımlarında uygulama dosyalarını kendiniz oluşturacaksınız.
+
+Ardından `cd awesome-project`, FastAPI eklenmeden önce yeni proje dizinine girer.
+
+`uv`, sisteminizde zaten kurulu olan uyumlu bir Python sürümünü kullanır veya gerekirse bir tane indirir.
+
+`uv add` çalıştırdığınızda, FastAPI'nin ve FastAPI'nin bağlı olduğu tüm paketlerin uyumlu sürümlerini seçer. Kesin sürümleri `uv.lock` içine kaydeder; bu da aynı paket sürümlerini daha sonra başka bir bilgisayarda veya uygulamayı deploy ederken kurmayı mümkün kılar.
+
+Bu dosyayı oluşturmak veya güncellemek, proje bağımlılıklarını [**lock'lamak**](https://docs.astral.sh/uv/concepts/projects/sync/) olarak adlandırılır. `uv`, bir paket eklediğinizde bunu otomatik olarak yapar.
+
+///
+
+/// details | FastAPI kurulum seçenekleri
+
+`uv add "fastapi[standard]"` ile kurduğunuzda, bazı varsayılan opsiyonel standart bağımlılıklarla birlikte gelir. Bunlara `fastapi-cloud-cli` da dahildir; bu sayede [FastAPI Cloud](https://fastapicloud.com)'a deploy edebilirsiniz.
+
+Bu opsiyonel bağımlılıkları istemiyorsanız bunun yerine `uv add fastapi` kurabilirsiniz.
+
+Standart bağımlılıkları kurmak istiyor ama `fastapi-cloud-cli` olmasın diyorsanız, `uv add "fastapi[standard-no-fastapi-cloud-cli]"` ile kurabilirsiniz.
+
+///
+
+/// details | Bunun yerine `pip` kullanmak
+
+Bir sanal ortamı ve paketleri manuel yönetmeyi tercih ediyorsanız, bir sanal ortam oluşturup etkinleştirin ve ardından FastAPI'yi `pip install "fastapi[standard]"` ile kurun.
+
+Ayrıntılı adımlar için [Sanal Ortamlar rehberini](https://tiangolo.com/guides/virtual-environments/) okuyun.
+
+///
+
+## AI Agent Skill'leri { #ai-agent-skills }
+
+FastAPI, AI kodlama agent'ları için resmi bir skill içerir. Paketle birlikte gelir; bu nedenle yönergeleri projenizde kurulu FastAPI sürümüyle uyumlu kalır ve FastAPI'yi güncellediğinizde güncellenir.
+
+Projenize FastAPI'yi kurduktan sonra, skill'i <a href="https://library-skills.io">Library Skills</a> ile kurabilirsiniz:
+
+```bash
+uvx library-skills
+```
+
 /// note | Not

-`pip install "fastapi[standard]"` ile kurduğunuzda, bazı varsayılan opsiyonel standart bağımlılıklarla birlikte gelir. Bunlara `fastapi-cloud-cli` da dahildir; bu sayede [FastAPI Cloud](https://fastapicloud.com)'a deploy edebilirsiniz.
-
-Bu opsiyonel bağımlılıkları istemiyorsanız bunun yerine `pip install fastapi` kurabilirsiniz.
-
-Standart bağımlılıkları kurmak istiyor ama `fastapi-cloud-cli` olmasın diyorsanız, `pip install "fastapi[standard-no-fastapi-cloud-cli]"` ile kurabilirsiniz.
+`uvx`, `uv tool run` için bir alias'tır. Library Skills projenizde kurulu paketleri tararken, Library Skills'i geçici ve izole bir ortamda çalıştırır.

 ///

-/// tip | İpucu
-
-FastAPI'nin [VS Code için resmi bir eklentisi](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (ve Cursor) vardır; path operation gezgini, path operation araması, testlerde CodeLens ile gezinme (testlerden tanıma atlama) ve FastAPI Cloud deploy ve logları gibi pek çok özelliği doğrudan editörünüzden sunar.
-
-///
+Skill; Codex, Claude Code, Cursor, GitHub Copilot, Gemini CLI, Pi, OpenCode ve diğer çoğu kodlama agent'ı ile uyumludur. Claude Code için, skill'in nereye kurulacağı sorulduğunda `.claude/skills` seçeneğini seçin.

 ## İleri Düzey Kullanıcı Rehberi { #advanced-user-guide }

@@ -37,7 +37,7 @@ Middleware fonksiyonu şunları alır:

 Özel (proprietary) header'lar [`X-` prefix'i kullanılarak](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) eklenebilir, bunu aklınızda tutun.

-Ancak tarayıcıdaki bir client'ın görebilmesini istediğiniz özel header'larınız varsa, bunları CORS konfigürasyonlarınıza ([CORS (Cross-Origin Resource Sharing)](cors.md)) eklemeniz gerekir. Bunun için, [Starlette'ın CORS dokümanlarında](https://www.starlette.dev/middleware/#corsmiddleware) belgelenen `expose_headers` parametresini kullanın.
+Ancak tarayıcıdaki bir client'ın görebilmesini istediğiniz özel header'larınız varsa, bunları CORS konfigürasyonlarınıza ([CORS (Cross-Origin Resource Sharing)](cors.md)) eklemeniz gerekir. Bunun için, [Starlette'ın CORS dokümanlarında](https://starlette.dev/middleware/#corsmiddleware) belgelenen `expose_headers` parametresini kullanın.

 ///

@@ -1,4 +1,4 @@
-# Yol Parametreleri { #path-parameters }
+# Path Parametreleri { #path-parameters }

 Python <abbr title="String Biçimleme: Format String">string biçimlemede</abbr> kullanılan sözdizimiyle path "parametreleri"ni veya "değişkenleri"ni tanımlayabilirsiniz:

@@ -12,7 +12,7 @@ Yani, bu örneği çalıştırıp [http://127.0.0.1:8000/items/foo](http://127.0
 {"item_id":"foo"}
 ```

-## Tip İçeren Yol Parametreleri { #path-parameters-with-types }
+## Tip İçeren Path Parametreleri { #path-parameters-with-types }

 Standart Python tip belirteçlerini kullanarak path parametresinin tipini fonksiyonun içinde tanımlayabilirsiniz:

@@ -92,7 +92,7 @@ Dikkat edin: path parametresi integer olarak tanımlanmıştır.

 ## Standartlara Dayalı Avantajlar, Alternatif Dokümantasyon { #standards-based-benefits-alternative-documentation }

-Üretilen şema [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md) standardından geldiği için birçok uyumlu araç vardır.
+Üretilen şema [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md) standardından geldiği için birçok uyumlu araç vardır.

 Bu nedenle **FastAPI**'ın kendisi, [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) adresinden erişebileceğiniz alternatif bir API dokümantasyonu (ReDoc kullanarak) sağlar:

@@ -102,7 +102,7 @@ Aynı şekilde, birçok uyumlu araç vardır. Birçok dil için kod üretme ara

 ## Pydantic { #pydantic }

-Tüm veri doğrulamaları, arka planda [Pydantic](https://docs.pydantic.dev/) tarafından gerçekleştirilir; böylece onun tüm avantajlarından faydalanırsınız. Ve emin ellerde olduğunuzu bilirsiniz.
+Tüm veri doğrulamaları, arka planda [Pydantic](https://pydantic.dev/docs/) tarafından gerçekleştirilir; böylece onun tüm avantajlarından faydalanırsınız. Ve emin ellerde olduğunuzu bilirsiniz.

 Aynı tip tanımlarını `str`, `float`, `bool` ve daha birçok karmaşık veri tipiyle kullanabilirsiniz.

@@ -371,11 +371,11 @@ Yukarıdaki parametrelerle yapılamayan bazı **özel doğrulama** ihtiyaçları

 Bu durumlarda, normal doğrulamadan sonra (ör. değerin `str` olduğunun doğrulanmasından sonra) uygulanacak bir **custom validator function** kullanabilirsiniz.

-Bunu, `Annotated` içinde [Pydantic’in `AfterValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator)’ını kullanarak yapabilirsiniz.
+Bunu, `Annotated` içinde [Pydantic’in `AfterValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-after-validator)’ını kullanarak yapabilirsiniz.

 /// tip | İpucu

-Pydantic’te [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) ve başka validator’lar da vardır. 🤓
+Pydantic’te [`BeforeValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-before-validator) ve başka validator’lar da vardır. 🤓

 ///

@@ -403,7 +403,7 @@ Bu custom validator’lar, request’te sağlanan **yalnızca** **aynı veri** i

 ---

-Ama bu örnek kodun detaylarını merak ediyorsanız, birkaç ek bilgi:
+Ama bu özel kod örneğini merak ediyorsanız ve hâlâ eğleniyorsanız, işte birkaç ek detay.

 #### `value.startswith()` ile String { #string-with-value-startswith }

@@ -6,10 +6,10 @@

 Upload edilen dosyaları alabilmek için önce [`python-multipart`](https://github.com/Kludex/python-multipart) yükleyin.

-Bir [Sanal ortam](../virtual-environments.md) oluşturduğunuzdan, aktive ettiğinizden ve ardından paketi yüklediğinizden emin olun. Örneğin:
+Projenize ekleyin:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 Bunun nedeni, upload edilen dosyaların "form data" olarak gönderilmesidir.
@@ -6,10 +6,10 @@ FastAPI'de **form field**'larını tanımlamak için **Pydantic model**'lerini k

 Form'ları kullanmak için önce [`python-multipart`](https://github.com/Kludex/python-multipart)'ı yükleyin.

-Bir [Sanal ortam](../virtual-environments.md) oluşturduğunuzdan, onu etkinleştirdiğinizden ve ardından paketi kurduğunuzdan emin olun. Örneğin:
+Projenize ekleyin:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -6,10 +6,10 @@

 Yüklenen dosyaları ve/veya form verisini almak için önce [`python-multipart`](https://github.com/Kludex/python-multipart) paketini kurun.

-Bir [sanal ortam](../virtual-environments.md) oluşturduğunuzdan, onu aktive ettiğinizden ve ardından paketi kurduğunuzdan emin olun, örneğin:
+Projenize ekleyin:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -1,16 +1,15 @@
 # Form Verisi { #form-data }

-
-JSON yerine form alanlarını almanız gerektiğinde `Form` kullanabilirsiniz.
+When you need to receive form fields instead of JSON, you can use `Form`.

 /// note | Not

 Formları kullanmak için önce [`python-multipart`](https://github.com/Kludex/python-multipart) paketini kurun.

-Bir [virtual environment](../virtual-environments.md) oluşturduğunuzdan, onu etkinleştirdiğinizden emin olun ve ardından örneğin şöyle kurun:
+Projenize ekleyin:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -76,16 +76,16 @@ Burada `UserIn` adında bir model declare ediyoruz; bu model plaintext bir passw

 `EmailStr` kullanmak için önce [`email-validator`](https://github.com/JoshData/python-email-validator) paketini kurun.

-Bir [virtual environment](../virtual-environments.md) oluşturduğunuzdan, onu aktive ettiğinizden emin olun ve ardından örneğin şöyle kurun:
+Projenize ekleyin:

 ```console
-$ pip install email-validator
+$ uv add email-validator
 ```

 veya şöyle:

 ```console
-$ pip install "pydantic[email]"
+$ uv add "pydantic[email]"
 ```

 ///
@@ -98,9 +98,9 @@ Artık bir browser password ile user oluşturduğunda, API response içinde ayn

 Bu örnekte sorun olmayabilir; çünkü password’ü gönderen kullanıcı zaten aynı kişi.

-Namun aynı modeli başka bir *path operation* için kullanırsak, kullanıcının password’lerini her client’a gönderiyor olabiliriz.
+Ama aynı modeli başka bir *path operation* için kullanırsak, kullanıcının password’lerini her client’a gönderiyor olabiliriz.

-/// danger
+/// danger | Tehlike

 Tüm riskleri bildiğinizden ve ne yaptığınızdan emin olmadığınız sürece, bir kullanıcının plain password’ünü asla saklamayın ve bu şekilde response içinde göndermeyin.

@@ -258,7 +258,7 @@ Ayrıca şunları da kullanabilirsiniz:
 * `response_model_exclude_defaults=True`
 * `response_model_exclude_none=True`

-Bunlar, `exclude_defaults` ve `exclude_none` için [Pydantic dokümanlarında](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) anlatıldığı gibidir.
+Bunlar, `exclude_defaults` ve `exclude_none` için [Pydantic dokümanlarında](https://pydantic.dev/docs/validation/latest/concepts/serialization/#excluding-and-including-fields-based-on-their-value) anlatıldığı gibidir.

 ///

@@ -12,7 +12,7 @@ Oluşturulan JSON Schema’ya eklenecek şekilde bir Pydantic model için `examp

 Bu ek bilgi, o modelin çıktı **JSON Schema**’sına olduğu gibi eklenir ve API dokümanlarında kullanılır.

-[Pydantic dokümanları: Configuration](https://docs.pydantic.dev/latest/api/config/) bölümünde anlatıldığı gibi, bir `dict` alan `model_config` niteliğini kullanabilirsiniz.
+[Pydantic dokümanları: Configuration](https://pydantic.dev/docs/validation/latest/api/pydantic/config/) bölümünde anlatıldığı gibi, bir `dict` alan `model_config` niteliğini kullanabilirsiniz.

 Üretilen JSON Schema’da görünmesini istediğiniz (ör. `examples` dahil) her türlü ek veriyi içeren bir `dict` ile `"json_schema_extra"` ayarlayabilirsiniz.

@@ -26,14 +26,14 @@ Güvenliği yönetmek için **FastAPI**’nin sunduğu araçları kullanalım.

 /// note | Not

-[`python-multipart`](https://github.com/Kludex/python-multipart) paketi, `pip install "fastapi[standard]"` komutunu çalıştırdığınızda **FastAPI** ile birlikte otomatik olarak kurulur.
+[`python-multipart`](https://github.com/Kludex/python-multipart) paketi, `uv add "fastapi[standard]"` komutunu çalıştırdığınızda **FastAPI** ile birlikte otomatik olarak kurulur.

-Ancak `pip install fastapi` komutunu kullanırsanız, `python-multipart` paketi varsayılan olarak dahil edilmez.
+Ancak `uv add fastapi` komutunu kullanırsanız, `python-multipart` paketi varsayılan olarak dahil edilmez.

-Elle kurmak için bir [Sanal ortam](../../virtual-environments.md) oluşturduğunuzdan, onu aktive ettiğinizden emin olun ve ardından şununla kurun:
+Elle kurmak için projenize şununla ekleyin:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 Bunun nedeni, **OAuth2**’nin `username` ve `password` göndermek için "form data" kullanmasıdır.
@@ -45,7 +45,7 @@ Bunun nedeni, **OAuth2**’nin `username` ve `password` göndermek için "form d
 <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)
 ```
@@ -30,12 +30,12 @@ JWT token'larıyla oynayıp nasıl çalıştıklarını görmek isterseniz [http

 Python'da JWT token'larını üretmek ve doğrulamak için `PyJWT` kurmamız gerekiyor.

-Bir [sanal ortam](../../virtual-environments.md) oluşturduğunuzdan emin olun, aktif edin ve ardından `pyjwt` kurun:
+Projenize `pyjwt` ekleyin:

 <div class="termy">

 ```console
-$ pip install pyjwt
+$ uv add pyjwt

 ---> 100%
 ```
@@ -72,12 +72,12 @@ Birçok güvenli hashing algoritmasını ve bunlarla çalışmak için yardımc

 Önerilen algoritma "Argon2"dir.

-Bir [sanal ortam](../../virtual-environments.md) oluşturduğunuzdan emin olun, aktif edin ve sonra Argon2 ile birlikte pwdlib'i kurun:
+Projenize Argon2 ile birlikte `pwdlib` ekleyin:

 <div class="termy">

 ```console
-$ pip install "pwdlib[argon2]"
+$ uv add "pwdlib[argon2]"

 ---> 100%
 ```
@@ -34,12 +34,12 @@ Bu çok basit ve kısa bir eğitimdir. Veritabanları genelinde, SQL hakkında v

 ## `SQLModel` Kurulumu { #install-sqlmodel }

-Önce [virtual environment](../virtual-environments.md) oluşturduğunuzdan emin olun, aktive edin ve ardından `sqlmodel`’i yükleyin:
+Projenize `sqlmodel` ekleyin:

 <div class="termy">

 ```console
-$ pip install sqlmodel
+$ uv add sqlmodel
 ---> 100%
 ```

@@ -152,7 +152,7 @@ Uygulamayı çalıştırabilirsiniz:
 <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 @@ Uygulamayı tekrar çalıştırabilirsiniz:
 <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)
 ```
@@ -45,4 +45,4 @@ Bu parametrelerin hepsi "`static`" ile aynı olmak zorunda değildir; kendi uygu

 ## Daha Fazla Bilgi { #more-info }

-Daha fazla detay ve seçenek için [Starlette'in Statik Dosyalar hakkındaki dokümanlarını](https://www.starlette.dev/staticfiles/) inceleyin.
+Daha fazla detay ve seçenek için [Starlette'in Statik Dosyalar hakkındaki dokümanlarını](https://starlette.dev/staticfiles/) inceleyin.
@@ -1,10 +1,10 @@
 # Test Etme { #testing }

-[Starlette](https://www.starlette.dev/testclient/) sayesinde **FastAPI** uygulamalarını test etmek kolay ve keyiflidir.
+[Starlette](https://starlette.dev/testclient/) sayesinde **FastAPI** uygulamalarını test etmek kolay ve keyiflidir.

 Temelde [HTTPX](https://www.python-httpx.org) üzerine kuruludur; HTTPX de Requests’i temel alarak tasarlandığı için oldukça tanıdık ve sezgiseldir.

-Bununla birlikte **FastAPI** ile [pytest](https://docs.pytest.org/)'i doğrudan kullanabilirsiniz.
+Bu sayede **FastAPI** ile [pytest](https://docs.pytest.org/)'i doğrudan kullanabilirsiniz.

 ## `TestClient` Kullanımı { #using-testclient }

@@ -12,10 +12,10 @@ Bununla birlikte **FastAPI** ile [pytest](https://docs.pytest.org/)'i doğrudan

 `TestClient` kullanmak için önce [`httpx`](https://www.python-httpx.org)'i kurun.

-Bir [Sanal Ortam](../virtual-environments.md) oluşturduğunuzdan, onu aktifleştirdiğinizden ve sonra kurulumu yaptığınızdan emin olun; örneğin:
+Projenize ekleyin:

 ```console
-$ pip install httpx
+$ uv add httpx
 ```

 ///
@@ -156,12 +156,12 @@ Testinizde bir Pydantic model'iniz varsa ve test sırasında verisini uygulamaya

 Bundan sonra yapmanız gereken tek şey `pytest`'i kurmaktır.

-Bir [Sanal Ortam](../virtual-environments.md) oluşturduğunuzdan, onu aktifleştirdiğinizden ve sonra kurulumu yaptığınızdan emin olun; örneğin:
+Projenize ekleyin:

 <div class="termy">

 ```console
-$ pip install pytest
+$ uv add pytest

 ---> 100%
 ```
@@ -175,7 +175,7 @@ Testleri şu şekilde çalıştırın:
 <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
@@ -1,864 +1,35 @@
-# Virtual Environments { #virtual-environments }
+# Virtual Environment'ler { #virtual-environments }

-Python projeleriyle çalışırken, her proje için kurduğunuz package'leri birbirinden izole etmek adına büyük ihtimalle bir **virtual environment** (veya benzer bir mekanizma) kullanmalısınız.
+Python projeleriyle çalışırken, her proje için kurulan package'leri izole etmek adına bir **virtual environment** kullanmalısınız.

-/// note | Not
-
-Virtual environment'leri, nasıl oluşturulduklarını ve nasıl kullanıldıklarını zaten biliyorsanız bu bölümü atlamak isteyebilirsiniz. 🤓
-
-///
-
-/// tip | İpucu
-
-**Virtual environment**, **environment variable** ile aynı şey değildir.
-
-**Environment variable**, sistemde bulunan ve programların kullanabildiği bir değişkendir.
-
-**Virtual environment** ise içinde bazı dosyalar bulunan bir klasördür.
-
-///
-
-/// note | Not
-
-Bu sayfada **virtual environment**'leri nasıl kullanacağınızı ve nasıl çalıştıklarını öğreneceksiniz.
-
-Eğer Python'ı kurmak dahil her şeyi sizin yerinize yöneten bir **tool** kullanmaya hazırsanız, [uv](https://github.com/astral-sh/uv)'yi deneyin.
-
-///
+FastAPI projeleri için projeyi, bağımlılıklarını ve virtual environment'ini yönetmek üzere [uv](https://docs.astral.sh/uv/) kullanmanızı öneririm.

 ## Proje Oluşturun { #create-a-project }

-Önce projeniz için bir klasör oluşturun.
-
-Ben genelde home/user klasörümün içinde `code` adlı bir klasör oluştururum.
-
-Sonra bunun içinde her proje için ayrı bir klasör oluştururum.
+`uv`'yi [resmi kurulum rehberini](https://docs.astral.sh/uv/getting-started/installation/) kullanarak kurun ve ardından bir proje oluşturun:

 <div class="termy">

 ```console
-// Gelelim home dizinine
-$ cd
-// Tüm kod projeleriniz için bir klasör oluşturun
-$ mkdir code
-// Bu code klasörüne girin
-$ cd code
-// Bu proje için bir klasör oluşturun
-$ mkdir awesome-project
-// Proje klasörüne girin
+$ uv init awesome-project --bare
 $ cd awesome-project
+$ uv add "fastapi[standard]"
 ```

 </div>

-## Virtual Environment Oluşturun { #create-a-virtual-environment }
+`uv`, proje için virtual environment'i otomatik olarak oluşturur. Kendiniz oluşturmanız veya aktive etmeniz gerekmez.

-Bir Python projesi üzerinde **ilk kez** çalışmaya başladığınızda, virtual environment'i **<dfn title="başka seçenekler de var, bu basit bir yönergedir">projenizin içinde</dfn>** oluşturun.
-
-/// tip | İpucu
-
-Bunu her çalıştığınızda değil, **proje başına sadece bir kez** yapmanız yeterlidir.
-
-///
-
-//// tab | `venv`
-
-Bir virtual environment oluşturmak için, Python ile birlikte gelen `venv` modülünü kullanabilirsiniz.
+Komutları projenin environment'i içinde `uv run` ile çalıştırın, örneğin:

 <div class="termy">

 ```console
-$ python -m venv .venv
+$ uv run fastapi dev
 ```

 </div>

-/// details | Bu komut ne anlama geliyor
+## Daha Fazla Bilgi Edinin { #learn-more }

-* `python`: `python` adlı programı kullan
-* `-m`: bir modülü script gibi çalıştır; bir sonraki kısımda hangi modül olduğunu söyleyeceğiz
-* `venv`: normalde Python ile birlikte kurulu gelen `venv` modülünü kullan
-* `.venv`: virtual environment'i yeni `.venv` klasörünün içine oluştur
-
-///
-
-////
-
-//// tab | `uv`
-
-Eğer [`uv`](https://github.com/astral-sh/uv) kuruluysa, onunla da virtual environment oluşturabilirsiniz.
-
-<div class="termy">
-
-```console
-$ uv venv
-```
-
-</div>
-
-/// tip | İpucu
-
-Varsayılan olarak `uv`, `.venv` adlı bir klasörde virtual environment oluşturur.
-
-Ancak ek bir argümanla klasör adını vererek bunu özelleştirebilirsiniz.
-
-///
-
-////
-
-Bu komut `.venv` adlı bir klasörün içinde yeni bir virtual environment oluşturur.
-
-/// details | `.venv` veya başka bir ad
-
-Virtual environment'i başka bir klasörde de oluşturabilirsiniz; ancak buna `.venv` demek yaygın bir konvansiyondur.
-
-///
-
-## Virtual Environment'i Aktif Edin { #activate-the-virtual-environment }
-
-Oluşturduğunuz virtual environment'i aktif edin; böylece çalıştırdığınız her Python komutu veya kurduğunuz her package onu kullanır.
-
-/// tip | İpucu
-
-Projede çalışmak için **yeni bir terminal oturumu** başlattığınız **her seferinde** bunu yapın.
-
-///
-
-//// 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
-
-Ya da Windows'ta Bash kullanıyorsanız (örn. [Git Bash](https://gitforwindows.org/)):
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-/// tip | İpucu
-
-Bu environment'e **yeni bir package** kurduğunuz her seferinde environment'i yeniden **aktif edin**.
-
-Böylece, o package'in kurduğu bir **terminal (<abbr title="command line interface - Komut Satırı Arayüzü">CLI</abbr>) programı** kullanıyorsanız, global olarak kurulu (ve muhtemelen ihtiyacınız olandan farklı bir versiyona sahip) başka bir program yerine, virtual environment'inizdeki programı kullanmış olursunuz.
-
-///
-
-## Virtual Environment'in Aktif Olduğunu Kontrol Edin { #check-the-virtual-environment-is-active }
-
-Virtual environment'in aktif olduğunu (bir önceki komutun çalıştığını) kontrol edin.
-
-/// tip | İpucu
-
-Bu **opsiyoneldir**; ancak her şeyin beklendiği gibi çalıştığını ve hedeflediğiniz virtual environment'i kullandığınızı **kontrol etmek** için iyi bir yöntemdir.
-
-///
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-$ which python
-
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-</div>
-
-Eğer `python` binary'sini projenizin içinde (bu örnekte `awesome-project`) `.venv/bin/python` yolunda gösteriyorsa, tamamdır. 🎉
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ Get-Command python
-
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-</div>
-
-Eğer `python` binary'sini projenizin içinde (bu örnekte `awesome-project`) `.venv\Scripts\python` yolunda gösteriyorsa, tamamdır. 🎉
-
-////
-
-## `pip`'i Yükseltin { #upgrade-pip }
-
-/// tip | İpucu
-
-[`uv`](https://github.com/astral-sh/uv) kullanıyorsanız, `pip` yerine onunla kurulum yaparsınız; dolayısıyla `pip`'i yükseltmeniz gerekmez. 😎
-
-///
-
-Package'leri kurmak için `pip` kullanıyorsanız (Python ile varsayılan olarak gelir), en güncel sürüme **yükseltmeniz** gerekir.
-
-Bir package kurarken görülen birçok garip hata, önce `pip`'i yükseltince çözülür.
-
-/// tip | İpucu
-
-Bunu genelde virtual environment'i oluşturduktan hemen sonra **bir kez** yaparsınız.
-
-///
-
-Virtual environment'in aktif olduğundan emin olun (yukarıdaki komutla) ve sonra şunu çalıştırın:
-
-<div class="termy">
-
-```console
-$ python -m pip install --upgrade pip
-
---> 100%
-```
-
-</div>
-
-/// tip | İpucu
-
-Bazen pip'i yükseltmeye çalışırken **`No module named pip`** hatası alabilirsiniz.
-
-Böyle olursa, aşağıdaki komutla pip'i kurup yükseltin:
-
-<div class="termy">
-
-```console
-$ python -m ensurepip --upgrade
-
---> 100%
-```
-
-</div>
-
-Bu komut pip kurulu değilse kurar ve ayrıca kurulu pip sürümünün `ensurepip` içinde bulunan sürüm kadar güncel olmasını garanti eder.
-
-///
-
-## `.gitignore` Ekleyin { #add-gitignore }
-
-**Git** kullanıyorsanız (kullanmalısınız), `.venv` içindeki her şeyi Git'ten hariç tutmak için bir `.gitignore` dosyası ekleyin.
-
-/// tip | İpucu
-
-Virtual environment'i [`uv`](https://github.com/astral-sh/uv) ile oluşturduysanız, bunu zaten sizin için yaptı; bu adımı atlayabilirsiniz. 😎
-
-///
-
-/// tip | İpucu
-
-Bunu virtual environment'i oluşturduktan hemen sonra **bir kez** yapın.
-
-///
-
-<div class="termy">
-
-```console
-$ echo "*" > .venv/.gitignore
-```
-
-</div>
-
-/// details | Bu komut ne anlama geliyor
-
-* `echo "*"`: terminale `*` metnini "yazar" (sonraki kısım bunu biraz değiştiriyor)
-* `>`: `>` işaretinin solundaki komutun terminale yazdıracağı çıktı, ekrana basılmak yerine sağ taraftaki dosyaya yazılsın
-* `.gitignore`: metnin yazılacağı dosyanın adı
-
-Git'te `*` "her şey" demektir. Yani `.venv` klasörü içindeki her şeyi ignore eder.
-
-Bu komut, içeriği şu olan bir `.gitignore` dosyası oluşturur:
-
-```gitignore
-*
-```
-
-///
-
-## Package'leri Kurun { #install-packages }
-
-Environment'i aktif ettikten sonra, içine package kurabilirsiniz.
-
-/// tip | İpucu
-
-Projede ihtiyaç duyduğunuz package'leri ilk kez kurarken veya yükseltirken bunu **bir kez** yapın.
-
-Bir sürümü yükseltmeniz veya yeni bir package eklemeniz gerekirse **tekrar** yaparsınız.
-
-///
-
-### Package'leri Doğrudan Kurun { #install-packages-directly }
-
-Acele ediyorsanız ve projenizin package gereksinimlerini bir dosyada belirtmek istemiyorsanız, doğrudan kurabilirsiniz.
-
-/// tip | İpucu
-
-Programınızın ihtiyaç duyduğu package'leri ve versiyonlarını bir dosyada tutmak (ör. `requirements.txt` veya `pyproject.toml`) (çok) iyi bir fikirdir.
-
-///
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install "fastapi[standard]"
-
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-Eğer [`uv`](https://github.com/astral-sh/uv) varsa:
-
-<div class="termy">
-
-```console
-$ uv pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-////
-
-### `requirements.txt`'ten Kurun { #install-from-requirements-txt }
-
-Bir `requirements.txt` dosyanız varsa, içindeki package'leri kurmak için artık onu kullanabilirsiniz.
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-Eğer [`uv`](https://github.com/astral-sh/uv) varsa:
-
-<div class="termy">
-
-```console
-$ uv pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-/// details | `requirements.txt`
-
-Bazı package'ler içeren bir `requirements.txt` şöyle görünebilir:
-
-```requirements.txt
-fastapi[standard]==0.113.0
-pydantic==2.8.0
-```
-
-///
-
-## Programınızı Çalıştırın { #run-your-program }
-
-Virtual environment'i aktif ettikten sonra programınızı çalıştırabilirsiniz; program, virtual environment'in içindeki Python'ı ve oraya kurduğunuz package'leri kullanır.
-
-<div class="termy">
-
-```console
-$ python main.py
-
-Hello World
-```
-
-</div>
-
-## Editörünüzü Yapılandırın { #configure-your-editor }
-
-Muhtemelen bir editör kullanırsınız; otomatik tamamlamayı ve satır içi hataları alabilmek için, editörünüzü oluşturduğunuz aynı virtual environment'i kullanacak şekilde yapılandırdığınızdan emin olun (muhtemelen otomatik algılar).
-
-Örneğin:
-
-* [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 | İpucu
-
-Bunu genelde yalnızca **bir kez**, virtual environment'i oluşturduğunuzda yapmanız gerekir.
-
-///
-
-## Virtual Environment'i Devre Dışı Bırakın { #deactivate-the-virtual-environment }
-
-Projeniz üzerinde işiniz bittiğinde virtual environment'i **deactivate** edebilirsiniz.
-
-<div class="termy">
-
-```console
-$ deactivate
-```
-
-</div>
-
-Böylece `python` çalıştırdığınızda, o virtual environment içinden (ve oraya kurulu package'lerle) çalıştırmaya çalışmaz.
-
-## Çalışmaya Hazırsınız { #ready-to-work }
-
-Artık projeniz üzerinde çalışmaya başlayabilirsiniz.
-
-
-
-/// tip | İpucu
-
-Yukarıdaki her şeyin aslında ne olduğunu anlamak ister misiniz?
-
-Okumaya devam edin. 👇🤓
-
-///
-
-## Neden Virtual Environment { #why-virtual-environments }
-
-FastAPI ile çalışmak için [Python](https://www.python.org/) kurmanız gerekir.
-
-Sonrasında FastAPI'yi ve kullanmak istediğiniz diğer tüm **package**'leri **kurmanız** gerekir.
-
-Package kurmak için genelde Python ile gelen `pip` komutunu (veya benzeri alternatifleri) kullanırsınız.
-
-Ancak `pip`'i doğrudan kullanırsanız, package'ler **global Python environment**'ınıza (Python'ın global kurulumuna) yüklenir.
-
-### Problem { #the-problem }
-
-Peki package'leri global Python environment'a kurmanın sorunu ne?
-
-Bir noktada, muhtemelen **farklı package**'lere bağımlı birçok farklı program yazacaksınız. Ayrıca üzerinde çalıştığınız bazı projeler, aynı package'in **farklı versiyonlarına** ihtiyaç duyacak. 😱
-
-Örneğin `philosophers-stone` adında bir proje oluşturduğunuzu düşünün; bu program, `harry` adlı başka bir package'e **`1` versiyonu ile** bağlı. Yani `harry`'yi kurmanız gerekir.
-
-```mermaid
-flowchart LR
-    stone(philosophers-stone) -->|requires| harry-1[harry v1]
-```
-
-Sonra daha ileri bir zamanda `prisoner-of-azkaban` adlı başka bir proje oluşturuyorsunuz; bu proje de `harry`'ye bağlı, fakat bu proje **`harry` versiyon `3`** istiyor.
-
-```mermaid
-flowchart LR
-    azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
-```
-
-Şimdi sorun şu: package'leri local bir **virtual environment** yerine global (global environment) olarak kurarsanız, `harry`'nin hangi versiyonunu kuracağınıza karar vermek zorunda kalırsınız.
-
-`philosophers-stone`'u çalıştırmak istiyorsanız önce `harry` versiyon `1`'i kurmanız gerekir; örneğin:
-
-<div class="termy">
-
-```console
-$ pip install "harry==1"
-```
-
-</div>
-
-Sonuç olarak global Python environment'ınızda `harry` versiyon `1` kurulu olur.
-
-```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
-```
-
-Fakat `prisoner-of-azkaban`'ı çalıştırmak istiyorsanız, `harry` versiyon `1`'i kaldırıp `harry` versiyon `3`'ü kurmanız gerekir (ya da sadece `3`'ü kurmak, otomatik olarak `1`'i kaldırabilir).
-
-<div class="termy">
-
-```console
-$ pip install "harry==3"
-```
-
-</div>
-
-Sonuç olarak global Python environment'ınızda `harry` versiyon `3` kurulu olur.
-
-Ve `philosophers-stone`'u tekrar çalıştırmaya kalkarsanız, `harry` versiyon `1`'e ihtiyaç duyduğu için **çalışmama** ihtimali vardır.
-
-```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 | İpucu
-
-Python package'lerinde **yeni versiyonlarda** **breaking change**'lerden kaçınmak oldukça yaygındır; ancak yine de daha güvenlisi, yeni versiyonları bilinçli şekilde kurmak ve mümkünse test'leri çalıştırıp her şeyin doğru çalıştığını doğrulamaktır.
-
-///
-
-Şimdi bunu, **projelerinizin bağımlı olduğu** daha **birçok** başka **package** ile birlikte düşünün. Yönetmesi epey zorlaşır. Sonunda bazı projeleri package'lerin **uyumsuz versiyonlarıyla** çalıştırıp, bir şeylerin neden çalışmadığını anlamamak gibi durumlara düşebilirsiniz.
-
-Ayrıca işletim sisteminize (örn. Linux, Windows, macOS) bağlı olarak Python zaten kurulu gelmiş olabilir. Bu durumda, sisteminizin **ihtiyaç duyduğu** bazı package'ler belirli versiyonlarla önceden kurulu olabilir. Global Python environment'a package kurarsanız, işletim sistemiyle gelen bazı programları **bozma** ihtimaliniz olabilir.
-
-## Package'ler Nereye Kuruluyor { #where-are-packages-installed }
-
-Python'ı kurduğunuzda, bilgisayarınızda bazı dosyalar içeren klasörler oluşturulur.
-
-Bu klasörlerin bir kısmı, kurduğunuz tüm package'leri barındırmaktan sorumludur.
-
-Şunu çalıştırdığınızda:
-
-<div class="termy">
-
-```console
-// Bunu şimdi çalıştırmayın, bu sadece bir örnek 🤓
-$ pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-Bu, FastAPI kodunu içeren sıkıştırılmış bir dosyayı genellikle [PyPI](https://pypi.org/project/fastapi/)'dan indirir.
-
-Ayrıca FastAPI'nin bağımlı olduğu diğer package'ler için de dosyaları **indirir**.
-
-Sonra tüm bu dosyaları **açar (extract)** ve bilgisayarınızdaki bir klasöre koyar.
-
-Varsayılan olarak bu indirilip çıkarılan dosyaları, Python kurulumunuzla birlikte gelen klasöre yerleştirir; yani **global environment**'a.
-
-## Virtual Environment Nedir { #what-are-virtual-environments }
-
-Global environment'da tüm package'leri bir arada tutmanın sorunlarına çözüm, çalıştığınız her proje için ayrı bir **virtual environment** kullanmaktır.
-
-Virtual environment, global olana çok benzeyen bir **klasördür**; bir projenin ihtiyaç duyduğu package'leri buraya kurarsınız.
-
-Böylece her projenin kendi virtual environment'i (`.venv` klasörü) ve kendi package'leri olur.
-
-```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'i Aktif Etmek Ne Demek { #what-does-activating-a-virtual-environment-mean }
-
-Bir virtual environment'i örneğin şununla aktif ettiğinizde:
-
-//// 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
-
-Ya da Windows'ta Bash kullanıyorsanız (örn. [Git Bash](https://gitforwindows.org/)):
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-Bu komut, sonraki komutlarda kullanılabilecek bazı [environment variable](environment-variables.md)'ları oluşturur veya değiştirir.
-
-Bunlardan biri `PATH` değişkenidir.
-
-/// tip | İpucu
-
-`PATH` environment variable hakkında daha fazla bilgiyi [Environment Variables](environment-variables.md#path-environment-variable) bölümünde bulabilirsiniz.
-
-///
-
-Bir virtual environment'i aktive etmek, onun `.venv/bin` (Linux ve macOS'ta) veya `.venv\Scripts` (Windows'ta) yolunu `PATH` environment variable'ına ekler.
-
-Diyelim ki environment'i aktive etmeden önce `PATH` değişkeni şöyleydi:
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Bu, sistemin programları şu klasörlerde arayacağı anlamına gelir:
-
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Windows\System32
-```
-
-Bu, sistemin programları şurada arayacağı anlamına gelir:
-
-* `C:\Windows\System32`
-
-////
-
-Virtual environment'i aktive ettikten sonra `PATH` değişkeni şuna benzer hale gelir:
-
-//// tab | Linux, macOS
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Bu, sistemin artık programları önce şurada aramaya başlayacağı anlamına gelir:
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin
-```
-
-diğer klasörlere bakmadan önce.
-
-Dolayısıyla terminale `python` yazdığınızda, sistem Python programını şurada bulur:
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-ve onu kullanır.
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32
-```
-
-Bu, sistemin artık programları önce şurada aramaya başlayacağı anlamına gelir:
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts
-```
-
-diğer klasörlere bakmadan önce.
-
-Dolayısıyla terminale `python` yazdığınızda, sistem Python programını şurada bulur:
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-ve onu kullanır.
-
-////
-
-Önemli bir detay: virtual environment yolu `PATH` değişkeninin **en başına** eklenir. Sistem, mevcut başka herhangi bir Python'ı bulmadan **önce** bunu bulur. Böylece `python` çalıştırdığınızda, başka bir `python` (örneğin global environment'tan gelen `python`) yerine **virtual environment'taki** Python kullanılır.
-
-Virtual environment'i aktive etmek birkaç şeyi daha değiştirir; ancak yaptığı en önemli işlerden biri budur.
-
-## Virtual Environment'i Kontrol Etmek { #checking-a-virtual-environment }
-
-Bir virtual environment'in aktif olup olmadığını örneğin şununla kontrol ettiğinizde:
-
-//// 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>
-
-////
-
-Bu, kullanılacak `python` programının **virtual environment'in içindeki** Python olduğu anlamına gelir.
-
-Linux ve macOS'ta `which`, Windows PowerShell'de ise `Get-Command` kullanırsınız.
-
-Bu komutun çalışma mantığı şudur: `PATH` environment variable içindeki **her yolu sırayla** dolaşır, `python` adlı programı arar. Bulduğunda, size o programın **dosya yolunu** gösterir.
-
-En önemli kısım şu: `python` dediğinizde çalışacak olan "`python`" tam olarak budur.
-
-Yani doğru virtual environment'da olup olmadığınızı doğrulayabilirsiniz.
-
-/// tip | İpucu
-
-Bir virtual environment'i aktive etmek kolaydır; sonra o Python ile kalıp **başka bir projeye geçmek** de kolaydır.
-
-Bu durumda ikinci proje, başka bir projenin virtual environment'ından gelen **yanlış Python**'ı kullandığınız için **çalışmayabilir**.
-
-Hangi `python`'ın kullanıldığını kontrol edebilmek bu yüzden faydalıdır. 🤓
-
-///
-
-## Neden Virtual Environment'i Deactivate Edelim { #why-deactivate-a-virtual-environment }
-
-Örneğin `philosophers-stone` projesi üzerinde çalışıyor olabilirsiniz; **o virtual environment'i aktive eder**, package kurar ve o environment ile çalışırsınız.
-
-Sonra **başka bir proje** olan `prisoner-of-azkaban` üzerinde çalışmak istersiniz.
-
-O projeye gidersiniz:
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-```
-
-</div>
-
-Eğer `philosophers-stone` için olan virtual environment'i deactivate etmezseniz, terminalde `python` çalıştırdığınızda `philosophers-stone`'dan gelen Python'ı kullanmaya çalışır.
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-$ python main.py
-
-// sirius import edilirken hata, kurulu değil 😱
-Traceback (most recent call last):
-    File "main.py", line 1, in <module>
-        import sirius
-```
-
-</div>
-
-Ama virtual environment'i deactivate edip `prisoner-of-azkaban` için yeni olanı aktive ederseniz, `python` çalıştırdığınızda `prisoner-of-azkaban` içindeki virtual environment'dan gelen Python kullanılır.
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-// Deactivate etmek için eski klasörde olmanız gerekmez; nerede olursanız olun, hatta diğer projeye geçtikten sonra bile yapabilirsiniz 😎
-$ deactivate
-
-// prisoner-of-azkaban/.venv içindeki virtual environment'i aktive edin 🚀
-$ source .venv/bin/activate
-
-// Artık python çalıştırdığınızda, bu virtual environment'e kurulu olan sirius package'ini bulacak ✨
-$ python main.py
-
-I solemnly swear 🐺
-```
-
-</div>
-
-## Alternatifler { #alternatives }
-
-Bu, başlamanız için basit bir rehber ve alttaki mekanizmaların nasıl çalıştığını öğretmeyi amaçlıyor.
-
-Virtual environment'leri, package bağımlılıklarını (requirements) ve projeleri yönetmek için birçok **alternatif** vardır.
-
-Hazır olduğunuzda ve package bağımlılıkları, virtual environment'ler vb. dahil **tüm projeyi yönetmek** için bir tool kullanmak istediğinizde, [uv](https://github.com/astral-sh/uv)'yi denemenizi öneririm.
-
-`uv` birçok şey yapabilir, örneğin:
-
-* Sizin için **Python kurabilir**, farklı sürümler dahil
-* Projelerinizin **virtual environment**'ini yönetebilir
-* **Package** kurabilir
-* Projeniz için package **bağımlılıklarını ve versiyonlarını** yönetebilir
-* Bağımlılıkları dahil, kurulacak package ve versiyonların **tam (exact)** bir setini garanti edebilir; böylece geliştirirken bilgisayarınızda çalıştırdığınız projeyi production'da da birebir aynı şekilde çalıştırabileceğinizden emin olursunuz; buna **locking** denir
-* Ve daha birçok şey
-
-## Sonuç { #conclusion }
-
-Buradaki her şeyi okuduysanız ve anladıysanız, artık birçok geliştiriciden **çok daha fazla** virtual environment bilgisine sahipsiniz. 🤓
-
-Bu detayları bilmek, ileride karmaşık görünen bir sorunu debug ederken büyük olasılıkla işinize yarayacak; çünkü **altta nasıl çalıştığını** biliyor olacaksınız. 😎
+Virtual environment'lerin altta nasıl çalıştığını, activation'ı ve alternatif `python -m venv` ile `pip` workflow'unu öğrenmek için [Virtual Environments rehberini](https://tiangolo.com/guides/virtual-environments/) okuyun.