diff --git a/docs/tr/docs/index.md b/docs/tr/docs/index.md
index 282e2b603..88660f7eb 100644
--- a/docs/tr/docs/index.md
+++ b/docs/tr/docs/index.md
@@ -6,7 +6,7 @@
- FastAPI framework, high performance, easy to learn, fast to code, ready for production
+ FastAPI framework, yüksek performanslı, öğrenmesi kolay, geliştirmesi hızlı, kullanıma sunulmaya hazır.
@@ -22,27 +22,27 @@
---
-**Documentation**: https://fastapi.tiangolo.com
+**dokümantasyon**: https://fastapi.tiangolo.com
-**Source Code**: https://github.com/tiangolo/fastapi
+**Kaynak kodu**: https://github.com/tiangolo/fastapi
---
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
+FastAPI, Python 3.6+'nın standart type hintlerine dayanan modern ve hızlı (yüksek performanslı) API'lar oluşturmak için kullanılabilecek web framework'ü.
-The key features are:
+Ana özellikleri:
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
+* **Hızlı**: çok yüksek performanslı, **NodeJS** ve **Go** ile eşdeğer seviyede performans sağlıyor, (Starlette ve Pydantic sayesinde.) [Python'un en hızlı frameworklerinden bir tanesi.](#performans).
+* **Kodlaması hızlı**: Yeni özellikler geliştirmek neredeyse %200 - %300 daha hızlı. *
+* **Daha az bug**: Geliştirici (insan) kaynaklı hatalar neredeyse %40 azaltıldı. *
+* **Sezgileri güçlü**: Editor (otomatik-tamamlama) desteği harika. Otomatik tamamlama her yerde. Debuglamak ile daha az zaman harcayacaksınız.
+* **Kolay**: Öğrenmesi ve kullanması kolay olacak şekilde. Doküman okumak için harcayacağınız süre azaltıldı.
+* **Kısa**: Kod tekrarını minimuma indirdik. Fonksiyon parametrelerinin tiplerini belirtmede farklı yollar sunarak karşılaşacağınız bug'ları azalttık.
+* **Güçlü**: Otomatik dokümantasyon ile beraber, kullanıma hazır kod yaz.
-* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
-* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
-* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
-* **Easy**: Designed to be easy to use and learn. Less time reading docs.
-* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
-* **Robust**: Get production-ready code. With automatic interactive documentation.
-* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
+* **Standartlar belirli**: Tamamiyle API'ların açık standartlara bağlı ve (tam uyumlululuk içerisinde); OpenAPI (eski adıyla Swagger) ve JSON Schema.
-* estimation based on tests on an internal development team, building production applications.
+* Bahsi geçen rakamsal ifadeler tamamiyle, geliştirme takımının kendi sundukları ürünü geliştirirken yaptıkları testlere dayanmakta.
## Sponsors
@@ -61,64 +61,72 @@ The key features are:
Other sponsors
-## Opinions
+## Görüşler
-"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
+
+"_[...] Bugünlerde **FastAPI**'ı çok fazla kullanıyorum [...] Aslına bakarsanız **Microsoft'taki Machine Learning servislerimizin** hepsinde kullanmayı düşünüyorum. FastAPI ile geliştirdiğimiz servislerin bazıları çoktan **Windows**'un ana ürünlerine ve **Office** ürünlerine entegre edilmeye başlandı bile._"
Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Timothy Crosley -
Hug'ın Yaratıcısı (ref)
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
+Eğer API yerine komut satırı uygulaması geliştiriyor isen **Typer**'a bir göz at.
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
+**Typer** kısaca FastAPI'ın küçük kız kardeşi. Komut satırı uygulamalarının **FastAPI'ı** olması hedeflendi. ⌨️ 🚀
-## Requirements
+## Gereksinimler
Python 3.6+
-FastAPI stands on the shoulders of giants:
+FastAPI iki devin omuzları üstünde duruyor:
-* Starlette for the web parts.
-* Pydantic for the data parts.
+* Web tarafı için Starlette.
+* Data tarafı için Pydantic.
-## Installation
+## Yükleme
@@ -130,7 +138,7 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
+Uygulamanı kullanılabilir hale getirmek için Uvicorn ya da Hypercorn gibi bir ASGI serverına ihtiyacın olacak.
@@ -142,11 +150,11 @@ $ pip install uvicorn[standard]
-## Example
+## Örnek
-### Create it
+### Şimdi dene
-* Create a file `main.py` with:
+* `main.py` adında bir dosya oluştur :
```Python
from typing import Optional
@@ -167,9 +175,9 @@ def read_item(item_id: int, q: Optional[str] = None):
```
-Or use async def...
+Ya da async def...
-If your code uses `async` / `await`, use `async def`:
+Eğer kodunda `async` / `await` var ise, `async def` kullan:
```Python hl_lines="9 14"
from typing import Optional
@@ -189,15 +197,15 @@ async def read_item(item_id: int, q: Optional[str] = None):
return {"item_id": item_id, "q": q}
```
-**Note**:
+**Not**:
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
+Eğer ne olduğunu bilmiyor isen _"Acelen mi var?"_ kısmını oku `async` ve `await`.
-### Run it
+### Çalıştır
-Run the server with:
+Serverı aşağıdaki komut ile çalıştır:
@@ -214,54 +222,54 @@ INFO: Application startup complete.
-About the command uvicorn main:app --reload...
+Çalıştırdığımız uvicorn main:app --reload hakkında...
-The command `uvicorn main:app` refers to:
+`uvicorn main:app` şunları ifade ediyor:
-* `main`: the file `main.py` (the Python "module").
-* `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
-* `--reload`: make the server restart after code changes. Only do this for development.
+* `main`: dosya olan `main.py` (yani Python "modülü").
+* `app`: ise `main.py` dosyasının içerisinde oluşturduğumuz `app = FastAPI()` 'a denk geliyor.
+* `--reload`: ise kodda herhangi bir değişiklik yaptığımızda serverın yapılan değişiklerileri algılayıp, değişiklikleri siz herhangi bir şey yapmadan uygulamasını sağlıyor.
-### Check it
+### Dokümantasyonu kontrol et
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
+Browserını aç ve şu linke git http://127.0.0.1:8000/items/5?q=somequery.
-You will see the JSON response as:
+Bir JSON yanıtı göreceksin:
```JSON
{"item_id": 5, "q": "somequery"}
```
-You already created an API that:
+Az önce oluşturduğun API:
-* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
-* Both _paths_ take `GET` operations (also known as HTTP _methods_).
-* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
-* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
+* `/` ve `/items/{item_id}` adreslerine HTTP talebi alabilir hale geldi.
+* İki _adresde_ `GET` operasyonlarını (HTTP _metodları_ olarakta bilinen) yapabilir hale geldi.
+* `/items/{item_id}` _adresi_ ayrıca bir `item_id` _adres parametresine_ sahip ve bu bir `int` olmak zorunda.
+* `/items/{item_id}` _adresi_ opsiyonel bir `str` _sorgu paramtersine_ sahip bu da `q`.
-### Interactive API docs
+### İnteraktif API dokümantasyonu
-Now go to http://127.0.0.1:8000/docs.
+Şimdi http://127.0.0.1:8000/docs adresine git.
-You will see the automatic interactive API documentation (provided by Swagger UI):
+Senin için otomatik oluşturulmuş(Swagger UI tarafından sağlanan) interaktif bir API dokümanı göreceksin:
-### Alternative API docs
+### Alternatif API dokümantasyonu
-And now, go to http://127.0.0.1:8000/redoc.
+Şimdi http://127.0.0.1:8000/redoc adresine git.
-You will see the alternative automatic documentation (provided by ReDoc):
+Senin için alternatif olarak (ReDoc tarafından sağlanan) bir API dokümantasyonu daha göreceksin:
-## Example upgrade
+## Örnek bir değişiklik
-Now modify the file `main.py` to receive a body from a `PUT` request.
+Şimdi `main.py` dosyasını değiştirelim ve body ile `PUT` talebi alabilir hale getirelim.
-Declare the body using standard Python types, thanks to Pydantic.
+Şimdi Pydantic sayesinde, Python'un standart tiplerini kullanarak bir body tanımlayacağız.
```Python hl_lines="4 9 10 11 12 25 26 27"
from typing import Optional
@@ -293,175 +301,175 @@ def update_item(item_id: int, item: Item):
return {"item_name": item.name, "item_id": item_id}
```
-The server should reload automatically (because you added `--reload` to the `uvicorn` command above).
+Server otomatik olarak yeniden başlamalı (çünkü yukarıda `uvicorn`'u çalıştırırken `--reload` parametresini kullandık.).
-### Interactive API docs upgrade
+### İnteraktif API dokümantasyonu'nda değiştirme yapmak
-Now go to http://127.0.0.1:8000/docs.
+Şimdi http://127.0.0.1:8000/docs bağlantısına tekrar git.
-* The interactive API documentation will be automatically updated, including the new body:
+* İnteraktif API dokümantasyonu, yeni body ile beraber çoktan yenilenmiş olması lazım:
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
+* "Try it out"a tıkla, bu senin API parametleri üzerinde deneme yapabilmene izin veriyor:
-* Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
+* Şimdi "Execute" butonuna tıkla, kullanıcı arayüzü otomatik olarak API'ın ile bağlantı kurarak ona bu parametreleri gönderecek ve sonucu karşına getirecek.
-### Alternative API docs upgrade
+### Alternatif API dokümantasyonunda değiştirmek
-And now, go to http://127.0.0.1:8000/redoc.
+Şimdi ise http://127.0.0.1:8000/redoc adresine git.
-* The alternative documentation will also reflect the new query parameter and body:
+* Alternatif dokümantasyonda koddaki değişimler ile beraber kendini yeni query ve body ile güncelledi.
-### Recap
+### Özet
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
+Özetleyecek olursak, URL, sorgu veya request body'deki parametrelerini fonksiyon parametresi olarak kullanıyorsun. Bu parametrelerin veri tiplerini bir kere belirtmen yeterli.
-You do that with standard modern Python types.
+Type-hinting işlemini Python dilindeki standart veri tipleri ile yapabilirsin
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
+Yeni bir syntax'e alışmana gerek yok, metodlar ve classlar zaten spesifik kütüphanelere ait.
-Just standard **Python 3.6+**.
+Sadece standart **Python 3.6+**.
-For example, for an `int`:
+Örnek olarak, `int` tanımlamak için:
```Python
item_id: int
```
-or for a more complex `Item` model:
+ya da daha kompleks `Item` tipi:
```Python
item: Item
```
-...and with that single declaration you get:
+...sadece kısa bir parametre tipi belirtmekle beraber, sahip olacakların:
-* Editor support, including:
- * Completion.
- * Type checks.
-* Validation of data:
- * Automatic and clear errors when the data is invalid.
- * Validation even for deeply nested JSON objects.
-* Conversion of input data: coming from the network to Python data and types. Reading from:
+* Editör desteği dahil olmak üzere:
+ * Otomatik tamamlama.
+ * Tip sorguları.
+* Datanın tipe uyumunun sorgulanması:
+ * Eğer data geçersiz ise, otomatik olarak hataları ayıklar.
+ * Çok derin JSON objelerinde bile veri tipi sorgusu yapar.
+* Gelen verinin dönüşümünü aşağıdaki veri tiplerini kullanarak gerçekleştirebiliyor.
* JSON.
- * Path parameters.
- * Query parameters.
+ * Path parametreleri.
+ * Query parametreleri.
* Cookies.
* Headers.
* Forms.
* Files.
-* Conversion of output data: converting from Python data and types to network data (as JSON):
- * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
- * `datetime` objects.
- * `UUID` objects.
- * Database models.
- * ...and many more.
-* Automatic interactive API documentation, including 2 alternative user interfaces:
+* Giden verinin dönüşümünü aşağıdaki veri tiplerini kullanarak gerçekleştirebiliyor (JSON olarak):
+ * Python tiplerinin (`str`, `int`, `float`, `bool`, `list`, vs) çevirisi.
+ * `datetime` objesi.
+ * `UUID` objesi.
+ * Veritabanı modelleri.
+ * ve daha fazlası...
+* 2 alternatif kullanıcı arayüzü dahil olmak üzere, otomatik interaktif API dokümanu:
* Swagger UI.
* ReDoc.
---
-Coming back to the previous code example, **FastAPI** will:
-
-* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
-* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
- * If it is not, the client will see a useful, clear error.
-* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
- * As the `q` parameter is declared with `= None`, it is optional.
- * Without the `None` it would be required (as is the body in the case with `PUT`).
-* For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
- * Check that it has a required attribute `name` that should be a `str`.
- * Check that it has a required attribute `price` that has to be a `float`.
- * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
- * All this would also work for deeply nested JSON objects.
-* Convert from and to JSON automatically.
-* Document everything with OpenAPI, that can be used by:
- * Interactive documentation systems.
- * Automatic client code generation systems, for many languages.
-* Provide 2 interactive documentation web interfaces directly.
+Az önceki kod örneğine geri dönelim, **FastAPI**'ın yapacaklarına bir bakış atalım:
+
+* `item_id`'nin `GET` ve `PUT` talepleri içinde olup olmadığının doğruluğunu kontol edecek.
+* `item_id`'nin tipinin `int` olduğunu `GET` ve `PUT` talepleri içinde olup olmadığının doğruluğunu kontol edecek.
+ * Eğer `GET` ve `PUT` içinde yok ise ve `int` değil ise, sebebini belirten bir hata mesajı gösterecek
+* Opsiyonel bir `q` parametresinin `GET` talebi için (`http://127.0.0.1:8000/items/foo?q=somequery` içinde) olup olmadığını kontrol edecek
+ * `q` parametresini `= None` ile oluşturduğumuz için, opsiyonel bir parametre olacak.
+ * Eğer `None` olmasa zorunlu bir parametre olacak idi (bu yüzden body'de `PUT` parametresi var).
+* `PUT` talebi için `/items/{item_id}`'nin body'sini, JSON olarak okuyor:
+ * `name` adında bir parametetre olup olmadığını ve var ise onun `str` olup olmadığını kontol ediyor.
+ * `price` adında bir parametetre olup olmadığını ve var ise onun `float` olup olmadığını kontol ediyor.
+ * `is_offer` adında bir parametetre olup olmadığını ve var ise onun `bool` olup olmadığını kontol ediyor.
+ * Bunların hepsini en derin JSON modellerinde bile yapacaktır.
+* Bütün veri tiplerini otomatik olarak JSON'a çeviriyor veya tam tersi.
+* Her şeyi dokümanlayıp, çeşitli yerlerde:
+ * İnteraktif dokümantasyon sistemleri.
+ * Otomatik alıcı kodu üretim sistemlerinde ve çeşitli dillerde.
+* İki ayrı web arayüzüyle direkt olarak interaktif bir dokümantasyon sunuyor.
---
-We just scratched the surface, but you already get the idea of how it all works.
+Henüz yüzeysel bir bakış attık, fakat sen çoktan çalışma mantığını anladın.
-Try changing the line with:
+Şimdi aşağıdaki satırı değiştirmeyi dene:
```Python
return {"item_name": item.name, "item_id": item_id}
```
-...from:
+...bundan:
```Python
... "item_name": item.name ...
```
-...to:
+...buna:
```Python
... "item_price": item.price ...
```
-...and see how your editor will auto-complete the attributes and know their types:
+...şimdi editör desteğinin nasıl veri tiplerini bildiğini ve otomatik tamamladığını gör:
-For a more complete example including more features, see the Tutorial - User Guide.
+Daha fazla örnek ve özellik için Tutorial - User Guide sayfasını git.
-**Spoiler alert**: the tutorial - user guide includes:
+**Spoiler**: Öğretici - Kullanıcı rehberi şunları içeriyor:
-* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
-* How to set **validation constraints** as `maximum_length` or `regex`.
-* A very powerful and easy to use **Dependency Injection** system.
-* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
-* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
-* Many extra features (thanks to Starlette) as:
+* **Parameterlerini** nasıl **headers**, **cookies**, **form fields** ve **files** olarak deklare edebileceğini.
+* `maximum_length` ya da `regex` gibi şeylerle nasıl **doğrulama** yapabileceğini.
+* Çok güçlü ve kullanımı kolay **Zorunluluk Entegrasyonu** oluşturmayı.
+* Güvenlik ve kimlik doğrulama, **JWT tokenleri**'yle beraber **OAuth2** desteği, ve **HTTP Basic** doğrulaması.
+* İleri seviye fakat ona göre oldukça basit olan **derince oluşturulmuş JSON modelleri** (Pydantic sayesinde).
+* Diğer ekstra özellikler (Starlette sayesinde):
* **WebSockets**
* **GraphQL**
- * extremely easy tests based on `requests` and `pytest`
+ * `requests` ve `pytest` sayesinde aşırı kolay testler.
* **CORS**
* **Cookie Sessions**
- * ...and more.
+ * ...ve daha fazlası.
-## Performance
+## Performans
-Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
+Bağımsız TechEmpower kıyaslamaları gösteriyor ki, Uvicorn'la beraber çalışan **FastAPI** uygulamaları Python'un en hızlı frameworklerinden birisi , sadece Starlette ve Uvicorn'dan daha yavaş ki FastAPI bunların üzerine kurulu.
-To understand more about it, see the section Benchmarks.
+Daha fazla bilgi için, bu bölüme bir göz at Benchmarks.
-## Optional Dependencies
+## Opsiyonel gereksinimler
-Used by Pydantic:
+Pydantic tarafında kullanılan:
-* ujson - for faster JSON "parsing".
-* email_validator - for email validation.
+* ujson - daha hızlı JSON "dönüşümü" için.
+* email_validator - email doğrulaması için.
-Used by Starlette:
+Starlette tarafında kullanılan:
-* requests - Required if you want to use the `TestClient`.
-* aiofiles - Required if you want to use `FileResponse` or `StaticFiles`.
-* jinja2 - Required if you want to use the default template configuration.
-* python-multipart - Required if you want to support form "parsing", with `request.form()`.
-* itsdangerous - Required for `SessionMiddleware` support.
-* pyyaml - Required for Starlette's `SchemaGenerator` support (you probably don't need it with FastAPI).
-* graphene - Required for `GraphQLApp` support.
-* ujson - Required if you want to use `UJSONResponse`.
+* requests - Eğer `TestClient` kullanmak istiyorsan gerekli.
+* aiofiles - `FileResponse` ya da `StaticFiles` kullanmak istiyorsan gerekli.
+* jinja2 - Eğer kendine ait template konfigürasyonu oluşturmak istiyorsan gerekli
+* python-multipart - Form kullanmak istiyorsan gerekli ("dönüşümü").
+* itsdangerous - `SessionMiddleware` desteği için gerekli.
+* pyyaml - `SchemaGenerator` desteği için gerekli (Muhtemelen FastAPI kullanırken ihtiyacınız olmaz).
+* graphene - `GraphQLApp` desteği için gerekli.
+* ujson - `UJSONResponse` kullanmak istiyorsan gerekli.
-Used by FastAPI / Starlette:
+Hem FastAPI hem de Starlette tarafından kullanılan:
-* uvicorn - for the server that loads and serves your application.
-* orjson - Required if you want to use `ORJSONResponse`.
+* uvicorn - oluşturduğumuz uygulamayı bir web sunucusuna servis etmek için gerekli
+* orjson - `ORJSONResponse` kullanmak istiyor isen gerekli.
-You can install all of these with `pip install fastapi[all]`.
+Bunların hepsini `pip install fastapi[all]` ile yükleyebilirsin.
-## License
+## Lisans
-This project is licensed under the terms of the MIT license.
+Bu proje, MIT lisansı şartlarına göre lisanslanmıştır.