diff --git a/docs/ka/docs/index.md b/docs/ka/docs/index.md
index 7d7d9686e..92557d3f1 100644
--- a/docs/ka/docs/index.md
+++ b/docs/ka/docs/index.md
@@ -36,33 +36,21 @@ hide:
---
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.
FastAPI არის თანამედროვე, სწრაფი (მაღალი წარმადობის მქონე), Python-ზე დაფუძნებული ვებფრეიმვორქი, რომელიც იყენებს Python-ის სტანდარტულ ტიპთა ანოტაციებს და საშუალებას გვაძლევს შევქმნათ API-ები.
-The key features are:
მისი ძირითადი მახასიათებლები გახლავთ:
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
* **სისწრაფე**: აქვს ძალიან მაღალი წარმადობა, როგორც **NodeJS**-სა და **Go**-ს (მადლობა Starlette-სა და Pydantic-ს). [ერთ-ერთი უსწრაფესი ფრეიმვორქია Python-ის არსებულ ფრეიმვორქებს შორის](#performance).
-* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
* **ეფექტურობა**: დეველოპმენტის პროცესს აჩქარებს დაახლოებით 200-300 პროცენტით. *
-* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
* **ნაკლები პროგრამული ხარვეზი**: ადამიანის (დეველოპერის) მიერ გამოწვეული ხარვეზების ალბათობას ამცირებს დაახლოებით 40 პროცენტით. *
-* **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.
* **სტანდარტებზე დაფუძნებულობა**: დაფუძნებულია (და სრულად თავსებადია) API-ებისთვის განსაზღვრულ ღია სტანდარტებზე: OpenAPI (ადრე ცნობილი იყო, როგორც Swagger) და JSON Schema.
-* estimation based on tests on an internal development team, building production applications.
* ზემოთ მოცემული შეფასებები ეფუძნება წარმოებაში ჩაშვებულ (რეალურ) აპლიკაციებზე მომუშავე შიდა დეველოპმენტის გუნდის ტესტებს.
-## Sponsors
## სპონსორები
@@ -78,75 +66,42 @@ The key features are:
-Other sponsors
სხვა სპონსორები
-## Opinions
## მოსაზრებები
-"_[...] 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._"
-
-Kabir Khan -
Microsoft (ref)Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)Deon Pillsbury -
Cisco (ref)
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
-თუკი მუშაობთ CLI აპლიკაციაზე, რომელიც გამოყენებულ იქნება ტერმინალში ვებ API-ის ნაცვლად, გაეცანით **Typer**-ს.
+თუკი მუშაობთ CLI აპლიკაციაზე, რომელიც გამოყენებულ იქნება ტერმინალში ვებ API-ის ნაცვლად, თვალი შეავლეთ **Typer**-ს.
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
-**Typer**-ი არის FastAPI-ის პატარა ძამიკო. მისი დანიშნულებაა, იყოს **ბრძანებათა სტრიქონის FastAPI**. ⌨️ 🚀
+**Typer**-ი არის FastAPI-ის პატარა ძამიკო. მისი დანიშნულებაა, იყოს **FastAPI ბრძანებათა სტრიქონისათვის**. ⌨️ 🚀
-## Requirements
## მოთხოვნები
-FastAPI stands on the shoulders of giants:
-FastAPI მხრებზე შემოსდგომია შემდეგ გიგანტებს:
+FastAPI მხრებზე შემოსდგომია ისეთ გიგანტებს, როგორებიცაა:
-* Starlette for the web parts.
* Starlette: ვების ნაწილში.
-* Pydantic for the data parts.
* Pydantic: მონაცემების ნაწილში.
-## Installation
## ინსტალაცია
@@ -200,13 +142,10 @@ $ pip install fastapi
-## Example
## მაგალითი
-### Create it
### შევქმნათ
-* Create a file `main.py` with:
* შექმენით `main.py` ფაილი შემდეგი შიგთავსით:
```Python
@@ -228,11 +167,9 @@ def read_item(item_id: int, q: Union[str, None] = None):
```
-Or use async def...
ან გამოიყენეთ async def...
-If your code uses `async` / `await`, use `async def`:
-თუკი თქვენი კოდი იყენებს `async` / `await`-ს, გამოიყენეთ `async def`:
+თუ თქვენი კოდი იყენებს `async` / `await` კონსტრუქციას, გამოიყენეთ `async def`:
```Python hl_lines="9 14"
from typing import Union
@@ -252,18 +189,14 @@ async def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}
```
-**Note**:
**შენიშვნა**:
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
-თუკი ჯერ ვერ ერკვევით აღნიშნულ საკითხში, `async`-ისა და `await`-ის შესახებ დოკუმენტაციაში გადახედეთ განყოფილებას სათაურით: _„გეჩქარებათ?“_.
+თუ თქვენ ჯერ ვერ ერკვევით აღნიშნულ საკითხში, `async`-ისა და `await`-ის შესახებ დოკუმენტაციაში გადახედეთ განყოფილებას, სათაურით: _„გეჩქარებათ?“_.
-### Run it
### გავუშვათ
-Run the server with:
გაუშვით სერვერი შემდეგი ბრძანებით:
@@ -294,74 +227,53 @@ INFO: Application startup complete.
-About the command fastapi dev main.py...
fastapi dev main.py ბრძანების შესახებ...
-The command `fastapi dev` reads your `main.py` file, detects the **FastAPI** app in it, and starts a server using Uvicorn.
`fastapi dev` ბრძანება კითხულობს თქვენს `main.py` ფაილს, მასში **FastAPI** აპლიკაციას აიდენტიფიცირებს და Uvicorn-ის გამოყენებით უშვებს სერვერს.
-By default, `fastapi dev` will start with auto-reload enabled for local development.
ნაგულისხმევად, ლოკალური დეველოპმენტისთვის, `fastapi dev` ბრძანებით გაშვებული სერვერისთვის აქტივირებული იქნება ავტოგადატვირთვის ფუნქცია.
-You can read more about it in the FastAPI CLI docs.
ამ საკითხთან დაკავშირებით დამატებითი ინფორმაცია შეგიძლიათ წაიკითხოთ FastAPI CLI-ის დოკუმენტაციაში.
-### Check it
### შევამოწმოთ
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
თქვენს ბრაუზერში გახსენით შემდეგი ბმული: http://127.0.0.1:8000/items/5?q=somequery.
-You will see the JSON response as:
დაინახავთ JSON ფორმატის მქონე მონაცემს:
```JSON
{"item_id": 5, "q": "somequery"}
```
-You already created an API that:
ამგვარად, თქვენ უკვე შექმენით API, რომელიც:
-* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
* იღებს HTTP მოთხოვნებს შემდეგ _მისამართებზე_: `/` და `/items/{item_id}`.
-* Both _paths_ take `GET` operations (also known as HTTP _methods_).
* ორივე _მისამართი_ ამუშავებს `GET` ოპერაციას (ასევე ცნობილს, როგორც HTTP _მეთოდი_).
-* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
* `/items/{item_id}` _მისამართს_ გააჩნია _მარშრუტის პარამეტრი_ `item_id`, რომელიც უნდა იყოს მთელი რიცხვის (`int`) ტიპის.
-* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
* `/items/{item_id}` მისამართს გააჩნია არასავალდებულო სტრიქონის (`str`) ტიპის _საძიებო (query) პარამეტრი_ `q`.
-### Interactive API docs
### ინტერაქციული API დოკუმენტაცია
-Now go to http://127.0.0.1:8000/docs.
გახსენით თქვენი ბრაუზერი და შედით ბმულზე: http://127.0.0.1:8000/docs.
-You will see the automatic interactive API documentation (provided by Swagger UI):
დაინახავთ ავტომატურად გენერირებულ ინტერაქციულ API დოკუმენტაციას (რომელიც უზრუნველყოფილია Swagger UI-ის მიერ):
-### Alternative API docs
### ალტერნატიული API დოკუმენტაცია
-And now, go to http://127.0.0.1:8000/redoc.
ბრაუზერში გახსენით შემდეგი ბმული: http://127.0.0.1:8000/redoc.
-You will see the alternative automatic documentation (provided by ReDoc):
დაინახავთ ალტერნატიულ ავტომატურად გენერირებულ დოკუმენტაციას (რომელიც უზრუნველყოფილია ReDoc-ის მიერ):
-## Example upgrade
## გაუმჯობესების მაგალითი
-Now modify the file `main.py` to receive a body from a `PUT` request.
-მოდით, შევცვალოთ `main.py` ფაილის შიგთავსი იმგვარად, რომ `PUT` ტიპის მოთხოვნით შევძლოთ მონაცემების მიღება.
+მოდით, შევცვალოთ `main.py` ფაილის შიგთავსი იმგვარად, რომ `PUT` ოპერაციით შევძლოთ მონაცემების მიღება.
-Declare the body using standard Python types, thanks to Pydantic.
მოვახდინოთ მოთხოვნის შიგთავსის პროტოტიპის დეკლარაცია Python-ის სტანდარტული ტიპების გამოყენებით. ამ შესაძლებლობას Pydantic-ს უნდა ვუმადლოდეთ.
```Python hl_lines="4 9-12 25-27"
@@ -394,94 +306,63 @@ def update_item(item_id: int, item: Item):
return {"item_name": item.name, "item_id": item_id}
```
-The `fastapi dev` server should reload automatically.
ცვლილებების შენახვის შემდეგ, `fastapi dev` ბრძანებით გაშვებული სერვერი, წესით და რიგით, ავტომატურად გადაიტვირთება.
-### Interactive API docs upgrade
### გავაუმჯობესოთ ინტერაქციული API დოკუმენტაცია
-Now go to http://127.0.0.1:8000/docs.
თქვენს ბრაუზერში გახსენით შემდეგი ბმული: http://127.0.0.1:8000/docs.
-* The interactive API documentation will be automatically updated, including the new body:
-* ინტერაქციული API დოკუმენტაცია, ახლად დამატებული პროტოტიპის ჩათვლით, განახლდება ავტომატურად:
+* ინტერაქციული API დოკუმენტაცია ავტომატურად განახლდება და ახლად დამატებული შიგთავსის პროტოტიპიც გამოჩნდება:
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
-* დააკლიკეთ "Try it out" ღილაკს. ეს საშუალებას მოგცემთ, განსაზღვროთ პარამეტრების მნიშვნელობები და API-სთან უშუალო ინტერაქციით დაკავდეთ:
+* დააკლიკეთ „Try it out“ ღილაკს. ეს საშუალებას მოგცემთ, ხელით გაწეროთ პარამეტრების მნიშვნელობები და API-სთან უშუალო ინტერაქციით დაკავდეთ:
-* 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:
-* შემდგომ ამისა, დააკლიკეთ "Execute" ღილაკს, რითაც თქვენ მიერ გახსნილი ინტერფეისი დაუკავშირდება API-ს, გაგზავნის თქვენ მიერ განსაზღვრულ პარამეტრებს, მიიღებს მოთხოვნის შედეგებს და გამოიტანს ეკრანზე:
+* შემდგომ ამისა, დააკლიკეთ „Execute“ ღილაკს, რითაც თქვენ მიერ გახსნილი ინტერფეისი დაუკავშირდება API-ს, გაგზავნის თქვენ მიერ განსაზღვრულ პარამეტრებს, მიიღებს მოთხოვნის შედეგებს და გამოიტანს ეკრანზე:
-### Alternative API docs upgrade
### გავაუმჯობესოთ ალტერნატიული API დოკუმენტაცია
-And now, go to http://127.0.0.1:8000/redoc.
ახლა კი, თქვენს ბრაუზერში გახსენით შემდეგი ბმული: http://127.0.0.1:8000/redoc.
-* The alternative documentation will also reflect the new query parameter and body:
-* ახლად დამატებული საძიებო პარამეტრი და შიგთავსის პროტოტიპი ალტერნატიულ დოკუმენტაციაშიც აისახება:
+* ახლად დამატებული საძიებო პარამეტრი და შიგთავსის პროტოტიპი ალტერნატიულ დოკუმენტაციაშიც ჰპოვებს ასახვას:
-### Recap
### შეჯამება
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
-მაშასადამე, პარამეტრების, შიგთავსის პროტოტიპებისა და სხვა ტიპების დეკლარირებას ახორციელებთ **ერთჯერადად**. როგორც ეს ხდება ფუნქციისათვის პარამეტრების განსაზღვრისას.
+ამრიგად, პარამეტრების, შიგთავსის პროტოტიპებისა და სხვა ტიპების დეკლარირებას ახორციელებთ **ერთჯერადად**. როგორც ფუნქციისათვის პარამეტრების განსაზღვრისას ხდება.
-You do that with standard modern Python types.
ამას აკეთებთ Python-ის თანამედროვე, სტანდარტული ტიპების გამოყენებით.
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
-არ გჭირდებათ რომელიმე ცალკეული ბიბლიოთეკისთვის დამახასიათებელი თავისებური სინტაქსის, მეთოდების ან კლასების შესწავლა.
+არ გჭირდებათ რომელიმე ცალკეული ბიბლიოთეკისთვის დამახასიათებელი განსხვავებული სინტაქსის, მეთოდების ან კლასების შესწავლა.
-Just standard **Python**.
იყენებთ მხოლოდ და მხოლოდ სტანდარტულ **Python**-ს.
-For example, for an `int`:
-მაგალითად, `int`-ის შემთხვევაში:
+მაგალითისათვის, `int`-ის შემთხვევაში:
```Python
item_id: int
```
-or for a more complex `Item` model:
ან შედარებით რთული `Item` მოდელისთვის:
```Python
item: Item
```
-...and with that single declaration you get:
...და ამ ერთი დეკლარაციით თქვენ მიიღებთ:
-* 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.
* მონაცემთა ვალიდაციას:
* ავტომატურად გენერირებულ და მარტივად გასაგებ ცდომილების შეტყობინებებს, როდესაც მონაცემები ვალიდური არ იქნება.
* ვალიდაციას თუნდაც უკიდურესად კომპლექსური (მაგ.: მრავალშრიანი) JSON მონაცემებისათვის.
-* Conversion of input data: coming from the network to Python data and types. Reading from:
- * JSON.
- * Path parameters.
- * Query parameters.
- * Cookies.
- * Headers.
- * Forms.
- * Files.
* შემავალ მონაცემთა გარდაქმნას: ქსელიდან შემომავალი მონაცემების გადათარგმნას Python-ისთვის გასაგებ მონაცემებად და ტიპებად. შესაძლებელია შემდეგი სახის მონაცემების წაკითხვა და გარდაქმნა:
* JSON.
* მარშრუტის (Path) პარამეტრები.
@@ -490,200 +371,131 @@ item: Item
* თავსართები (Headers).
* ფორმები.
* ფაილები.
-* 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.
* გამომავალ მონაცემთა გარდაქმნას: Python-ის მონაცემებისა და ტიპების გადათარგმნას ქსელურ მონაცემებად (JSON-ად). შესაძლებელია შემდეგი სახის მონაცემების გარდაქმნა:
* Python-ის ტიპები (`str`, `int`, `float`, `bool`, `list` და სხვ.).
* `datetime` ობიექტები.
* `UUID` ობიექტები.
* მონაცემთა ბაზის მოდელები.
* ...და მრავალი სხვა.
-* Automatic interactive API documentation, including 2 alternative user interfaces:
- * Swagger UI.
- * ReDoc.
* ავტომატურად გენერირებულ ინტერაქციულ API დოკუმენტაციას, რომელიც მოიცავს 2 ალტერნატიულ ინტერფეისს. ესენია:
* Swagger UI.
* ReDoc.
---
-Coming back to the previous code example, **FastAPI** will:
მოდით, მივუბრუნდეთ წინა მაგალითს და გავაანალიზოთ, რას და როგორ გააკეთებს **FastAPI**:
-* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
* `GET` და `PUT` ოპერაციებისათვის შეამოწმებს, არის თუ არა `item_id` პარამეტრი მითითებული მისამართში.
-* 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.
* `GET` და `PUT` ოპერაციებისათვის გადაამოწმებს, არის თუ არა `item_id` პარამეტრი `int` ტიპის.
* თუ ეს ასე არ იქნება, კლიენტი იხილავს გამოსადეგ, მარტივად გასაგებ ცდომილების შეტყობინებას.
-* 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`).
* `GET` ოპერაციებისათვის შეამოწმებს, არის თუ არა მისამართში წარმოდგენილი არასავალდებულო საძიებო (query) პარამეტრი, სახელად `q` (მაგ.: `http://127.0.0.1:8000/items/foo?q=somequery`).
* ვინაიდან `q` პარამეტრი კოდში განსაზღვრულია `= None` ბოლოსართით, იგი არასავალდებულოა.
* `None`-ის არარსებობის შემთხვევაში, იგი იქნებოდა სავალდებულო (მსგავსად მოთხოვნის შიგთავსისა `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.
* `/items/{item_id}` მისამართზე `PUT` ოპერაციისას, წაიკითხავს მოთხოვნის შიგთავსს, როგორც JSON ფორმატის მქონე მონაცემს. ამასთან:
* შეამოწმებს, არის თუ არა განსაზღვრული `str` ტიპის სავალდებულო `name` ატრიბუტი.
* შეამოწმებს, არის თუ არა განსაზღვრული `float` ტიპის სავალდებულო `price` ატრიბუტი.
* შეამოწმებს, მოთხოვნის შიგთავსში არის თუ არა წარმოდგენილი `bool` ტიპის არასავალდებულო `is_offer` ატრიბუტი.
* ყველაფერი ეს იმუშავებს ნებისმიერი სახის (მაგ.: მრავალშრიანი) JSON მონაცემისათვის.
* Convert from and to JSON automatically.
-* ავტომატურად გარდაქმნის JSON-ს სხვა სახის მონაცემად და პირიქით.
-* Document everything with OpenAPI, that can be used by:
- * Interactive documentation systems.
- * Automatic client code generation systems, for many languages.
+* ავტომატურად გარდაქმნის JSON-ს სხვა ფორმატის მქონე მონაცემად და პირიქით.
* OpenAPI-ით მოახდენს ყველაფრის დოკუმენტირებას, რაც გამოსადეგი იქნება:
* ინტერაქციული დოკუმენტაციის სისტემებისათვის.
* კლიენტის კოდის ავტომატიზირებული გენერირების სისტემებისათვის სხვადასხვა ენაში.
-* Provide 2 interactive documentation web interfaces directly.
* უშუალოდ უზრუნველყოფს 2 ალტერნატიული ინტერაქციული დოკუმენტაციის ვებინტერფეისის არსებობას.
---
-We just scratched the surface, but you already get the idea of how it all works.
-ჯერჯერობით ჩვენ რაც განვიხილეთ, მხოლოდ და მხოლოდ ზედაპირია აისბერგისა, მაგრამ, ასე თუ ისე, ალბათ გაიაზრეთ ზოგადი პრინციპი, თუ როგორ მუშაობს ეს ყველაფერი.
+ჯერჯერობით ჩვენ რაც განვიხილეთ, მხოლოდ და მხოლოდ ზედაპირია აისბერგისა, მაგრამ, ასე თუ ისე, ალბათ გაიაზრეთ ამ ყველაფრის მუშაობის ზოგადი პრინციპი.
-Try changing the line with:
სცადეთ შემდეგ ხაზში ცვლილების შეტანა:
```Python
return {"item_name": item.name, "item_id": item_id}
```
-...from:
...ადრე:
```Python
... "item_name": item.name ...
```
-...to:
...ახლა:
```Python
... "item_price": item.price ...
```
-...and see how your editor will auto-complete the attributes and know their types:
...და დააკვირდით, როგორ მოახდენს თქვენი ტექსტური რედაქტორი ატრიბუტების ავტოდასრულებას და მათი ტიპების იდენტიფიცირებას:
-For a more complete example including more features, see the Tutorial - User Guide.
მეტად სრულყოფილი მაგალითის სანახავად, სადაც განხილული იქნება უფრო მეტი საკითხი, იხილეთ სახელმძღვანელო — მომხმარებლის გზამკვლევი.
-**Spoiler alert**: the tutorial - user guide includes:
**გაფრთხილება სპოილერის შესახებ**: მომხმარებლის გზამკვლევი მოიცავს შემდეგ საკითხებს:
-* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
* **პარამეტრების** დეკლარირება სხვა წყაროებიდან, როგორებიცაა: **თავსართები (headers)**, **cookie-ები**, **ფორმის ველები** და **ფაილები**.
-* How to set **validation constraints** as `maximum_length` or `regex`.
* **შემმოწმებლებისათვის (ვალიდატორებისათვის) შეზღუდვების** დაწესება, როგორებიცაა: `maximum_length` ან `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.
* უსაფრთხოება და ავთენტიკაცია, მათ შორის **OAuth2**-ის მხარდაჭერა **JWT ტოკენებით** და **HTTP Basic** ავთენტიკაცია.
-* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
* მეტად სიღრმისეული (მაგრამ ისეთივე მარტივი) მეთოდოლოგიები **კომპლექსური (მრავალშრიანი) JSON მოდელების** დეკლარირებისათვის (მადლობა Pydantic-ს).
-* **GraphQL** integration with Strawberry and other libraries.
-* **GraphQL**-ის ინტეგრირება Strawberry-სთან და სხვა ბიბლიოთეკებთან.
-* Many extra features (thanks to Starlette) as:
- * **WebSockets**
- * extremely easy tests based on HTTPX and `pytest`
- * **CORS**
- * **Cookie Sessions**
- * ...and more.
-* არაერთი სხვა თავისებურება (მადლობა Starlette-ს), როგორებიცაა:
+* **GraphQL**-ის ინტეგრირება Strawberry-სთან და სხვა ბიბლიოთეკებთან ერთად.
+* არაერთი სხვა ფუნქციონალი (მადლობა Starlette-ს), როგორებიცაა:
* **ვებსოკეტები**
* HTTPX-ზე და `pytest`-ზე დაფუძნებული უმარტივესი ტესტები
* **CORS**
* **Cookie სესიები**
* ...და მრავალი სხვა.
-## Performance
## წარმადობა
-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). (*)
TechEmpower-ის მიუკერძოებელი ტესტები ცხადყოფენ, რომ Uvicorn-ით გაშვებული **FastAPI**-ზე დაფუძნებული აპლიკაციები წარმოაჩენენ FastAPI-ს, როგორც ერთ-ერთ უსწრაფეს ფრეიმვორქს Python-ის არსებულ ფრეიმვორქებს შორის. მას წინ უსწრებენ მხოლოდ Starlette-ი და Uvicorn-ი (რომლებსაც, თავის მხრივ, FastAPI-ი იყენებს). (*)
-To understand more about it, see the section Benchmarks.
ამ ყველაფრის უკეთ გასააზრებლად იხილეთ შემდეგი განყოფილება: წარმადობის ტესტები (Benchmarks).
-## Dependencies
## პაკეტები
-Used by Pydantic:
-Pydantic-ის მიერ გამოიყენება:
+Pydantic-ის მიერ გამოიყენება შემდეგი პაკეტები:
-* email_validator - for email validation.
-* email_validator - მეილის ვალიდაციისათვის.
-* pydantic-settings - for settings management.
-* pydantic-settings - პარამეტრების სამართავად.
-* pydantic-extra-types - for extra types to be used with Pydantic.
-* pydantic-extra-types - Pydantic-თან ერთად გამოყენებადი დამატებითი ტიპებისათვის.
+* email_validator — მეილის ვალიდაციისათვის.
+* pydantic-settings — პარამეტრების სამართავად.
+* pydantic-extra-types — Pydantic-თან ერთად გამოყენებადი დამატებითი ტიპებისათვის.
-Used by Starlette:
-Starlette-ის მიერ გამოიყენება:
+Starlette-ის მიერ გამოიყენება შემდეგი პაკეტები:
-* httpx - Required if you want to use the `TestClient`.
-* httpx - სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ `TestClient`-ი .
-* jinja2 - Required if you want to use the default template configuration.
-* jinja2 - სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ შაბლონის ნაგულისხმევი კონფიგურაცია.
-* python-multipart - Required if you want to support form "parsing", with `request.form()`.
-* python-multipart - სავალდებულოა, თუკი გსურთ, რომ გქონდეთ ფორმების „პარსინგის“ შესაძლებლობა `request.form()`-ის გამოყენებით.
+* httpx — სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ `TestClient`-ი .
+* jinja2 — სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ შაბლონის ნაგულისხმევი კონფიგურაცია.
+* python-multipart — სავალდებულოა, თუკი გსურთ, რომ გქონდეთ ფორმების „პარსინგის“ შესაძლებლობა `request.form()`-ის გამოყენებით.
-Used by FastAPI / Starlette:
-FastAPI / Starlette-ის მიერ გამოიყენება:
+FastAPI / Starlette-ის მიერ გამოიყენება შემდეგი პაკეტები:
-* uvicorn - for the server that loads and serves your application.
-* uvicorn - სერვერისთვის, რომელიც ემსახურება თქვენი აპლიკაციის ჩატვირთვას და მუშაობას.
-* `fastapi-cli` - to provide the `fastapi` command.
-* `fastapi-cli` - უზრუნველყოფს `fastapi` ბრძანების ხელმისაწვდომობას.
+* uvicorn — სერვერისთვის, რომელიც ემსახურება თქვენი აპლიკაციის ჩატვირთვას და მუშაობას.
+* `fastapi-cli` — უზრუნველყოფს `fastapi` ბრძანების ხელმისაწვდომობას.
-When you install `fastapi` it comes these standard dependencies.
`fastapi`-ის ინსტალირებისას, მასთან ერთად ინსტალირდება ზემოთ ჩამოთვლილი სტანდარტული პაკეტებიც.
-Additional optional dependencies:
-დამატებითი არასავალდებულო პაკეტები:
+დამატებითი არასავალდებულო პაკეტები გახლავთ:
-* orjson - Required if you want to use `ORJSONResponse`.
-* orjson - სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ `ORJSONResponse`-ი.
-* ujson - Required if you want to use `UJSONResponse`.
-* ujson - სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ `UJSONResponse`-ი.
+* orjson — სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ `ORJSONResponse`-ი.
+* ujson — სავალდებულოა, თუკი გსურთ, რომ გამოიყენოთ `UJSONResponse`-ი.
## `fastapi-slim`
-If you don't want the extra standard optional dependencies, install `fastapi-slim` instead.
თუ არ გჭირდებათ დამატებითი არასავალდებულო სტანდარტული პაკეტები, `fastapi`-ის ნაცვლად დააინსტალირეთ `fastapi-slim`-ი.
-When you install with:
როდესაც ინსტალაციას ახორციელებთ შემდეგი ბრძანებით:
```bash
pip install fastapi
```
-...it includes the same code and dependencies as:
...ინსტალირდება იგივე კოდი და პაკეტები, რაც დაინსტალირდებოდა შემდეგი ბრძანების გამოყენების შემთხვევაში:
```bash
pip install "fastapi-slim[standard]"
```
-The standard extra dependencies are the ones mentioned above.
-არასავალდებულო სტანდარტულ პაკეტებში იგულისხმება ზემოთ ნახსენები პაკეტები.
+არასავალდებულო სტანდარტულ პაკეტებში იგულისხმება ზემოთ მოხსენიებული პაკეტები.
-## License
## ლიცენზია
-This project is licensed under the terms of the MIT license.
წინამდებარე პროექტზე ვრცელდება MIT ლიცენზიით გათვალისწინებული წესები და პირობები.