diff --git a/docs/en/mkdocs.yml b/docs/en/mkdocs.yml
index e9a639d0b..16f779935 100644
--- a/docs/en/mkdocs.yml
+++ b/docs/en/mkdocs.yml
@@ -6,7 +6,7 @@ theme:
name: material
custom_dir: ../en/overrides
palette:
- - media: "(prefers-color-scheme)"
+ - media: (prefers-color-scheme)
toggle:
icon: material/lightbulb-auto
name: Switch to light mode
@@ -27,7 +27,6 @@ theme:
features:
- content.code.annotate
- content.code.copy
- # - content.code.select
- content.footnote.tooltips
- content.tabs.link
- content.tooltips
@@ -35,7 +34,6 @@ theme:
- navigation.indexes
- navigation.instant
- navigation.instant.prefetch
- # - navigation.instant.preview
- navigation.instant.progress
- navigation.path
- navigation.tabs
@@ -46,7 +44,6 @@ theme:
- search.share
- search.suggest
- toc.follow
-
icon:
repo: fontawesome/brands/github-alt
logo: img/icon-white.svg
@@ -55,11 +52,7 @@ theme:
repo_name: fastapi/fastapi
repo_url: https://github.com/fastapi/fastapi
plugins:
- # Material for MkDocs
- search:
- # Configured in mkdocs.insiders.yml
- # social:
- # Other plugins
+ search: null
macros:
include_yaml:
- external_links: ../en/data/external_links.yml
@@ -103,7 +96,6 @@ plugins:
signature_crossrefs: true
show_symbol_type_heading: true
show_symbol_type_toc: true
-
nav:
- FastAPI: index.md
- features.md
@@ -258,33 +250,27 @@ nav:
- benchmarks.md
- management.md
- release-notes.md
-
markdown_extensions:
- # Python Markdown
- abbr:
- attr_list:
- footnotes:
- md_in_html:
- tables:
+ abbr: null
+ attr_list: null
+ footnotes: null
+ md_in_html: null
+ tables: null
toc:
permalink: true
-
- # Python Markdown Extensions
- pymdownx.betterem:
- pymdownx.caret:
+ pymdownx.betterem: null
+ pymdownx.caret: null
pymdownx.highlight:
line_spans: __span
- pymdownx.inlinehilite:
- pymdownx.keys:
- pymdownx.mark:
+ pymdownx.inlinehilite: null
+ pymdownx.keys: null
+ pymdownx.mark: null
pymdownx.superfences:
custom_fences:
- name: mermaid
class: mermaid
- format: !!python/name:pymdownx.superfences.fence_code_format
- pymdownx.tilde:
-
- # pymdownx blocks
+ format: !!python/name:pymdownx.superfences.fence_code_format ''
+ pymdownx.tilde: null
pymdownx.blocks.admonition:
types:
- note
@@ -295,17 +281,13 @@ markdown_extensions:
- tip
- hint
- warning
- # Custom types
- info
- check
- pymdownx.blocks.details:
+ pymdownx.blocks.details: null
pymdownx.blocks.tab:
- alternate_style: True
-
- # Other extensions
- mdx_include:
- markdown_include_variants:
-
+ alternate_style: true
+ mdx_include: null
+ markdown_include_variants: null
extra:
analytics:
provider: google
@@ -313,16 +295,14 @@ extra:
feedback:
title: Was this page helpful?
ratings:
- - icon: material/emoticon-happy-outline
- name: This page was helpful
- data: 1
- note: >-
- Thanks for your feedback!
- - icon: material/emoticon-sad-outline
- name: This page could be improved
- data: 0
- note: >-
- Thanks for your feedback!
+ - icon: material/emoticon-happy-outline
+ name: This page was helpful
+ data: 1
+ note: Thanks for your feedback!
+ - icon: material/emoticon-sad-outline
+ name: This page could be improved
+ data: 0
+ note: Thanks for your feedback!
social:
- icon: fontawesome/brands/github-alt
link: https://github.com/fastapi/fastapi
@@ -338,7 +318,6 @@ extra:
link: https://medium.com/@tiangolo
- icon: fontawesome/solid/globe
link: https://tiangolo.com
-
alternate:
- link: /
name: en - English
@@ -372,6 +351,8 @@ extra:
name: pl - Polski
- link: /pt/
name: pt - português
+ - link: /ro/
+ name: ro - Română
- link: /ru/
name: ru - русский язык
- link: /tr/
@@ -390,14 +371,11 @@ extra:
name: zh-hant - 繁體中文
- link: /em/
name: 😉
-
extra_css:
- css/termynal.css
- css/custom.css
-
extra_javascript:
- js/termynal.js
- js/custom.js
-
hooks:
- ../../scripts/mkdocs_hooks.py
diff --git a/docs/ro/docs/index.md b/docs/ro/docs/index.md
new file mode 100644
index 000000000..da9555c19
--- /dev/null
+++ b/docs/ro/docs/index.md
@@ -0,0 +1,495 @@
+
+{!../../docs/missing-translation.md!}
+
+
+# FastAPI
+
+
+
+
+ 
+
+
+ Framework-ul FastAPI: perfromanță superioară, ușor de învățat, rapid de codat, pregătit pentru producție
+
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+---
+
+**Documentație**: https://fastapi.tiangolo.com
+
+**Cod sursă**: https://github.com/fastapi/fastapi
+
+---
+
+FastAPI este un *framework web* modern, foarte performant (rapid), pentru implementarea de API-uri în Python care se bazează pe *type hints*-urile standard din Python.
+
+Caractersticile cheie sunt:
+
+* **Rapid**: Performanță foarte ridicată, la paritate cu **NodeJS** și **Go**, datorită librăriilor Starlette și Pydantic. [Una dintre cele mai rapide librării Python disponbile](#performance).
+* **Rapid de codat**: Accelerează viteza de implementare a funcționalităților cu aproape 200% până la 300%. *
+* **Mai puține *bug*-uri**: Reduce cu până la 40% erorile cauzate de programator. *
+* **Intuitiv**: Suport excelent pentru editoare de cod. Completare automata a codului.. Mai puțin timp petrecut cu depanarea.
+* **Facil**: Proiectat astfel încât să fie ușor de folosit și învățat. Mai puțin timp cu citirea documentației.
+* **Scurt**: Minimizează duplicarea de code. Funcționalități multiple din fiecare parametru declarat. Mai puține *bug*-uri.
+* **Robust**: Cod gata pentru producție, cu documentație interactiva generată automat.
+* **Standardizat**: Se bazeaza și este in totalitate compatibil cu specificațiile OpenAPI (cunoscut în trecut ca Swagger) și JSON Schema.
+
+* estimare bazată pe testele efectuate de o echipa internă, construind aplicații pentru producție.
+
+## Sponsori
+
+
+
+{% if sponsors %}
+{% for sponsor in sponsors.gold -%}
+
+{% endfor -%}
+{%- for sponsor in sponsors.silver -%}
+
+{% endfor %}
+{% endif %}
+
+
+
+Alți sponsori
+
+## Opinii
+
+"_[...] 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)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)
+
+Dacă dezvolți o aplicație în interfațâ linie de comandă pe care să o folosești in terminal în loc de *browser*, verifică **Typer**.
+**Typer** este fratele mai mic al FastAPI și este **interfața linie de comanda pentru FastAPI**. ⌨️ 🚀
+
+## Cerințe
+
+FastAPI se bazează pe doi giganți:
+
+* Starlette pentru procesarea *web*.
+* Pydantic pentru procesarea datelor.
+
+## Instalare
+
+Crează și activează un mediu virtual, după care instalează FastAPI:
+
+
+
+```console
+$ pip install "fastapi[standard]"
+
+---> 100%
+```
+
+
+
+**Notă**: Asigură-te ca pui `"fastapi[standard]"` intre ghilimele, ca să te asiguri ca functionează în orice terminal.
+
+## Exemplu
+
+### Crează
+
+* Crează un fișier `main.py` care va conține:
+
+```Python
+from typing import Union
+
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/")
+def read_root():
+ return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: Union[str, None] = None):
+ return {"item_id": item_id, "q": q}
+```
+
+
+Sau folosește async def...
+
+Dacă ai în cod `async` / `await`, folosește `async def`:
+
+```Python hl_lines="9 14"
+from typing import Union
+
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/")
+async def read_root():
+ return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: int, q: Union[str, None] = None):
+ return {"item_id": item_id, "q": q}
+```
+
+**Notă**:
+
+Dacă nu ești sigur, verifică documentația la secțiunea _"În grabă?"_ pentru mai multe detalii pentru `async` și `await`.
+
+
+
+### Execută
+
+Pornește *server*-ul web cu:
+
+
+
+```console
+$ fastapi dev main.py
+
+ ╭────────── FastAPI CLI - Development mode ───────────╮
+ │ │
+ │ Serving at: http://127.0.0.1:8000 │
+ │ │
+ │ API docs: http://127.0.0.1:8000/docs │
+ │ │
+ │ Running in development mode, for production use: │
+ │ │
+ │ fastapi run │
+ │ │
+ ╰─────────────────────────────────────────────────────╯
+
+INFO: Will watch for changes in these directories: ['/home/user/code/awesomeapp']
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+INFO: Started reloader process [2248755] using WatchFiles
+INFO: Started server process [2248757]
+INFO: Waiting for application startup.
+INFO: Application startup complete.
+```
+
+
+
+
+Despre instrucțiunea fastapi dev main.py...
+
+Instrucțiunea `fastapi dev` citește fișierul `main.py`, detectează prezența **FastAPI** și pornește un *server web* bazat pe Uvicorn.
+
+Implicit, `fastapi dev` va porni cu modul auto-încărcare activat pentru dezvolatre locală.
+
+Poți afla mai multe în Documentație FastAPI ILC docs.
+
+
+
+### Verifică
+
+Deschide *browser*-ul la http://127.0.0.1:8000/items/5?q=somequery.
+
+În format JSON, vei vedea următorul răspuns:
+
+```JSON
+{"item_id": 5, "q": "somequery"}
+```
+
+Asftel, ai creat un API care:
+
+* Primște o cerere HTTP pe ruta _paths_ `/` și `/items/{item_id}`.
+* Ambele rute răspund la o operațiune `GET` (cunoscută si ca _verb_ HTTP).
+* Ruta _path_ `/items/{item_id}` are un prametru de cale `item_id` care trebuie sa fie un `int`
+* Ruta _path_ `/items/{item_id}` are un _parametru de interogare_ `q` care este un tip de dată `str`.
+
+### Documentație API interactivă
+
+Acum navighează către http://127.0.0.1:8000/docs.
+
+Vei observa documentatia API generata interactiv (furnizată de Swagger UI):
+
+
+
+### Documentație API alternativă
+
+Dacă navighezi către http://127.0.0.1:8000/redoc, vei vedea documentația API alternativa generată cu ReDoc:
+
+
+
+## Actualizare (Exemplu)
+
+Acum modifică fișierul `main.py` astfel încât o `PUT` să primească un corp în cerere.
+
+Mulțumită Pydantic, poți declara corpul cererii folosind tipuri standard din Python
+
+```Python hl_lines="4 9-12 25-27"
+from typing import Union
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ price: float
+ is_offer: Union[bool, None] = None
+
+
+@app.get("/")
+def read_root():
+ return {"Hello": "World"}
+
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: Union[str, None] = None):
+ return {"item_id": item_id, "q": q}
+
+
+@app.put("/items/{item_id}")
+def update_item(item_id: int, item: Item):
+ return {"item_name": item.name, "item_id": item_id}
+```
+
+Server-ul `fastapi dev` se va reîncărca automat.
+
+### Actualizarea documentației API interactive
+
+Navighează catre http://127.0.0.1:8000/docs.
+
+* Documentația API interactivă va fi actualizată automat, incluzând noul corp al cererii HTTP:
+
+
+
+* Dă click pe butonul "Try it out", care iți va permite sa completezi valoarea parametrilor si să interacționezi direct cu *API*-ul:
+
+
+
+* Acum dă click pe butonul "Execute". Interfața grafică va comunica cu API-ul tău, va trimite parametrii, va primi raspunsul pe care îl va afișa pe ecran:
+
+
+
+### Actualizarea documentației API alternative
+
+Acum, navighează către http://127.0.0.1:8000/redoc.
+
+* Documentația API alternativă, reflecta noul parametru de interogare precum și corpul cererii:
+
+
+
+### Recapitulare
+
+Pe scurt, declari **o singură data** tipurile de parametrii, corpul, etc. ca argumente intr-o funcție.
+
+Aceasta este posibil prin intermediul tipurilor moderne de date standard din Python.
+
+Nu este nevoie să înveți o noua sintaxă, metodele sau clasele unui librarări speciale, etc.
+
+Doar **Python** standard.
+
+De examplu, pentru un `int`:
+
+```Python
+item_id: int
+```
+
+sau pentru un model mai complex precum `Item`:
+
+```Python
+item: Item
+```
+
+...astfel, cu o singura declarație obții:
+
+* Suport la editare, incluzând:
+ * Autocompletare.
+ * Verificare de tip.
+* Validarea datelor:
+ * Errori clare si gestionate automat când datele sunt invalide.
+ * Validare disponibilă chiar si pentru obiecte JSON profund imbricate.
+* Conversia datelor de intrare dispre rețea către date și tipuri Python. Citește din:
+ * JSON.
+ * Parametrii de cale.
+ * Parametrii de interogare.
+ * Cookie-uri.
+ * Anteturi HTTP.
+ * Formulare HTML.
+ * Fișiere.
+* Conversia datelor de ieșire dinspre date și tipuri Python către date de rețea precum JSON:
+ * Conversie de tipuri de date Python (`str`, `int`, `float`, `bool`, `list`, etc).
+ * Obiecte `datetime`.
+ * Obiecte `UUID`.
+ * Modele de baze de date.
+ * ...și multe altele.
+* Documentație API interactivă, generata automat incluzând două interfețe grafice alternative bazate pe:
+ * Swagger UI.
+ * ReDoc.
+
+---
+
+Revenind la codul din exemplul anterior, **FastAPI** efectuează următoareleȘ
+
+* Validează că există un `item_id` în calea cererilor `GET` și `PUT`.
+* Validează că `item_id` este de tip `int` pentru cererile `GET` și `PUT`:
+ * Dacă nu este, clientul va primi un mesaj de erorare clar și folositor
+* Verifică dacă exista un parametru de interogare opțional numit `q` (așa cum apare in `http://127.0.0.1:8000/items/foo?q=somequery`) pentru cererea `GET` /
+ * Deoarece parametrul `q` este declarat cu `= None`, acesta este opțional.
+ * Fără `None`, ar fi obligatoriu (așa cum este corpul cererii in cazul `PUT`).
+* Pentru cererile `PUT` către `/items/{item_id}`, citește corpul cererii ca JSON:
+ * Verifică că acesta conține un atribut obligatoriu `name`, care trebuie să fie de tip `str`.
+ * Verifică că acesta conține un atribut obligatoriu `price`, care trebuie să fie de tip `float`.
+ * Verifică că acesta conține un atribut opțional `is_offer`, care trebuie să fie de tip `bool`, dacă este prezent.
+ * Toate aceste verificări se aplică și pentru obiectele JSON **profund imbricate**.
+* Conversia din și în JSON se realizează automat.
+* Documentează totul utilizând **OpenAPI**, care poate fi folosit pentru:
+ * Sisteme interactive de documentație.
+ * Sisteme automate de generare de cod client, pentru multiple limbaje de programare.
+* Oferă două interfețe web interactive pentru documentație.
+
+---
+
+Deși am atins doar suprafața subiectului, deja ai o idee despre modul în care functionează totul.
+
+Încearcă să înlocuiești liniile de mai jos:
+
+```Python
+ return {"item_name": item.name, "item_id": item_id}
+```
+
+...de la:
+
+```Python
+ ... "item_name": item.name ...
+```
+
+...la:
+
+```Python
+ ... "item_price": item.price ...
+```
+
+...și observă cum editorul tau va completa automat atributele și va recunoaște tipurile acestora:
+
+
+
+Pentru un exemplu mai complet, care include mai multe funcționalități, consultă Tutorial - Ghidul utilizatorului.
+
+**Atenție, spoiler!** "Tutorialul - Ghidul utilizatorului" include:
+* Declararea **parametrilor** din diverse surse, cum ar fi: **anteturi (headers)**, **cookie-uri**, **câmpuri de formular HTML** și **fișiere**.
+* Modul de configurare a restricțiilor de validare, precum `maximum_length` sau `regex`.
+* Un sistem de **Injecție de dependențe** foarte puternic și ușor de utilizat.
+* Securitate și autentificare, inclusiv suport pentru **OAuth2** cu **token-uri JWT** și autentificare **HTTP Basic**.
+* Tehnici mai avansate (dar la fel de simple) pentru definirea **modelelor JSON profund imbricate** (datorită Pydantic).
+* Integrarea **GraphQL** cu Strawberry și alte biblioteci.
+* Multe funcționalități suplimentare (datorită Starlette), precum:
+ * **WebSockets**
+ * Teste extrem de simple bazate pe HTTPX și `pytest`
+ * **CORS**
+ * Sesiuni bazate pe Cookie-uri
+ * ...și multe altele.
+
+
+## Performanța
+
+Benchmark-urile independente realizate de TechEmpower arată că aplicațiile bazate pe FastAPI, rulând sub Uvicorn, sunt printre cele mai rapide aplicații Python disponibile, fiind depășite doar de Starlette și Uvicorn (utilizate intern de FastAPI). (*)
+
+Pentru a înțelege mai bine acest aspect, consultă secțiunea Benchmark-uri.
+
+## Dependențe
+
+FastAPI depinde de Pydantic si Starlette.
+
+### Dependențe `standard`
+
+Când instalezi FastAPI cu `pip install "fastapi[standard]"`, acesta include grupul de dependențe opționale standard:
+
+Utilizate de Pydantic:
+ * email-validator – pentru validarea adreselor de email.
+
+Utilizate de Starlette:
+ * httpx – necesar dacă dorești să utilizezi TestClient.
+ * jinja2 – necesar dacă dorești să utilizezi configurația implicită a șabloanelor.
+ * python-multipart – necesar dacă dorești suort pentru "parsing-ul" formularelor, utilizând request.form().
+
+Utilizate de FastAPI / Starlette:
+ * uvicorn – pentru serverul care încarcă și servește aplicația. Acesta include uvicorn[standard], care conține unele dependențe (de exemplu, uvloop) necesare pentru un server de înaltă performanță.
+ * fastapi-cli – oferă interfața linie de comanda fastapi.
+
+### Fără dependențele standard
+
+Dacă nu dorești să incluzi dependențele opționale standard, poți instala FastAPI cu `pip install fastapi` în loc de `pip install "fastapi[standard]"`.
+
+### Dependențe opționale suplimentare
+
+Există și alte dependențe suplimentare pe care le poți instala, în funcție de necesități.
+
+Dependențe opționale suplimentare pentru Pydantic:
+
+* pydantic-settings – pentru gestionarea configurațiilor și a setărilor.
+* pydantic-extra-types – oferă tipuri suplimentare utilizabile cu Pydantic.
+
+Dependențe opționale suplimentare pentru FastAPI:
+
+* orjson – necesar dacă dorești să utilizezi ORJSONResponse.
+* ujson – necesar dacă dorești să utilizezi UJSONResponse.
+
+## Licență
+
+Acest proiect este licențiat sub termenii de licențiere MIT.
diff --git a/docs/ro/mkdocs.yml b/docs/ro/mkdocs.yml
new file mode 100644
index 000000000..de18856f4
--- /dev/null
+++ b/docs/ro/mkdocs.yml
@@ -0,0 +1 @@
+INHERIT: ../en/mkdocs.yml