diff --git a/docs/es/docs/index.md b/docs/es/docs/index.md
index 7a12add10..28a5d4067 100644
--- a/docs/es/docs/index.md
+++ b/docs/es/docs/index.md
@@ -2,7 +2,7 @@
- FastAPI framework, high performance, easy to learn, fast to code, ready for production
+ FastAPI framework, alto desempeño, fácil de aprender, rápido de programar, listo para producción
@@ -21,29 +21,28 @@
---
-**Documentation**: https://fastapi.tiangolo.com
+**Documentación**: https://fastapi.tiangolo.com
-**Source Code**: https://github.com/tiangolo/fastapi
+**Código Fuente**: https://github.com/tiangolo/fastapi
---
+FastAPI es un web framework moderno y rápido (de alto rendimiento) para construir APIs con Python 3.6+ basado en las anotaciones de tipos estándar de Python.
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
+Sus características principales son:
-The key features are:
+* **Rapidez**: Alto rendimiento, a la par con **NodeJS** y **Go** (gracias a Starlette y Pydantic). [Uno de los frameworks de Python más rápidos](#rendimiento).
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
+* **Rápido de programar**: Incrementa la velocidad de desarrollo entre 200% y 300% *.
+* **Menos errores**: Reduce los errores humanos (de programador) aproximadamente un 40% *.
+* **Intuitivo**: Gran soporte en los editores con auto completado en todas partes. Gasta menos tiempo debugging.
+* **Fácil**: Está diseñado para ser fácil de usar y aprender. Gastando menos tiempo leyendo documentación.
+* **Corto**: Minimiza la duplicación de código. Múltiples funcionalidades con cada declaración de parámetros. Menos errores.
+* **Robusto**: Crea código listo para producción con documentación automática interactiva.
+* **Basado en estándares**: Basado y totalmente compatible con los estándares abiertos para APIs: OpenAPI (conocido previamente como Swagger) y JSON Schema.
-* **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.
+* Esta estimación está basada en pruebas con un equipo de desarrollo interno contruyendo aplicaciones listas para producción.
-* estimation based on tests on an internal development team, building production applications.
-
-## Opinions
+## Opiniones
"*[...] 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.*"
@@ -77,24 +76,24 @@ The key features are:
---
-## **Typer**, the FastAPI of CLIs
+## **Typer**, el FastAPI de las CLIs
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
+Si estás construyendo un app de CLI para ser usada en la terminal en vez de una API web, fíjate en **Typer**.
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
+**Typer** es el hermano menor de FastAPI. La intención es que sea el **FastAPI de las CLIs**. ⌨️ 🚀
-## Requirements
+## Requisitos
Python 3.6+
-FastAPI stands on the shoulders of giants:
+FastAPI está sobre los hombros de gigantes:
-* Starlette for the web parts.
-* Pydantic for the data parts.
+* Starlette para las partes web.
+* Pydantic para las partes de datos.
-## Installation
+## Instalación
@@ -106,7 +105,7 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
+También vas a necesitar un servidor ASGI para producción cómo Uvicorn o Hypercorn.
@@ -118,11 +117,11 @@ $ pip install uvicorn
-## Example
+## Ejemplo
-### Create it
+### Créalo
-* Create a file `main.py` with:
+* Crea un archivo `main.py` con:
```Python
from fastapi import FastAPI
@@ -141,9 +140,9 @@ def read_item(item_id: int, q: str = None):
```
-Or use async def...
+O usa async def...
-If your code uses `async` / `await`, use `async def`:
+Si tu código usa `async` / `await`, usa `async def`:
```Python hl_lines="7 12"
from fastapi import FastAPI
@@ -161,15 +160,15 @@ async def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
```
-**Note**:
+**Nota**:
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
+Si no lo sabes, revisa la sección _"¿Con prisa?"_ sobre `async` y `await` en la documentación.
-### Run it
+### Córrelo
-Run the server with:
+Corre el servidor con:
@@ -186,54 +185,54 @@ $ uvicorn main:app --reload
-About the command uvicorn main:app --reload...
+Sobre el comando uvicorn main:app --reload...
-The command `uvicorn main:app` refers to:
+El comando `uvicorn main:app` se refiere a:
-* `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`: el archivo `main.py` (el"modulo" de Python).
+* `app`: el objeto creado dentro de `main.py` con la línea `app = FastAPI()`.
+* `--reload`: hace que el servidor se reinicie después de cambios en el código. Esta opción solo debe ser usada en desarrollo.
-### Check it
+### Revísalo
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
+Abre tu navegador en http://127.0.0.1:8000/items/5?q=somequery.
-You will see the JSON response as:
+Verás la respuesta de JSON cómo:
```JSON
{"item_id": 5, "q": "somequery"}
```
-You already created an API that:
+Ya creaste una API que:
-* 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`.
+* Recibe HTTP requests en los _paths_ `/` y `/items/{item_id}`.
+* Ambos _paths_ toman operaciones `GET` (también conocido como HTTP _methods_).
+* El _path_ `/items/{item_id}` tiene un _path parameter_ `item_id` que debería ser un `int`.
+* El _path_ `/items/{item_id}` tiene un `str` _query parameter_ `q` opcional.
-### Interactive API docs
+### Documentación interactiva de APIs
-Now go to http://127.0.0.1:8000/docs.
+Ahora ve a http://127.0.0.1:8000/docs.
-You will see the automatic interactive API documentation (provided by Swagger UI):
+Verás la documentación automática e interactiva de la API (proveída por Swagger UI):
-### Alternative API docs
+### Documentación alternativa de la API
-And now, go to http://127.0.0.1:8000/redoc.
+Ahora, ve a http://127.0.0.1:8000/redoc.
-You will see the alternative automatic documentation (provided by ReDoc):
+Ahora verás la documentación automática alternativa (proveída por ReDoc):
-## Example upgrade
+## Mejora al ejemplo
-Now modify the file `main.py` to receive a body from a `PUT` request.
+Ahora modifica el archivo `main.py` para recibir un body del `PUT` request.
-Declare the body using standard Python types, thanks to Pydantic.
+Declara el body usando las declaraciones de tipo estándares de Python gracias a Pydantic.
```Python hl_lines="2 7 8 9 10 23 24 25"
from fastapi import FastAPI
@@ -263,175 +262,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).
+El servidor debería recargar automáticamente (porque añadiste `--reload` al comando `uvicorn` que está más arriba).
-### Interactive API docs upgrade
+### Mejora a la documentación interactiva de APIs
-Now go to http://127.0.0.1:8000/docs.
+Ahora ve a http://127.0.0.1:8000/docs.
-* The interactive API documentation will be automatically updated, including the new body:
+* La documentación interactiva de la API se actualizará automáticamente, incluyendo el nuevo body:
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
+* Haz clíck en el botón de "Try it out" que te permite llenar los parámetros e interactuar directamente con la 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:
+* Luego haz clíck en el botón de "Execute". La interfaz de usuario se comunicará con tu API, enviará los parámetros y recibirá los resultados para mostrarlos en pantalla:
-### Alternative API docs upgrade
+### Mejora a la documentación alternativa de la API
-And now, go to http://127.0.0.1:8000/redoc.
+Ahora, ve a http://127.0.0.1:8000/redoc.
-* The alternative documentation will also reflect the new query parameter and body:
+* La documentación alternativa también reflejará el nuevo parámetro de query y el body:
-### Recap
+### Resumen
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
+En resumen, declaras los tipos de parámetros, body, etc. **una vez** como parámetros de la función.
-You do that with standard modern Python types.
+Lo haces con tipos modernos estándar de Python.
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
+No tienes que aprender una sintáxis nueva, los métodos o clases de una library específica, etc.
-Just standard **Python 3.6+**.
+Solo **Python 3.6+** estándar.
-For example, for an `int`:
+Por ejemplo, para un `int`:
```Python
item_id: int
```
-or for a more complex `Item` model:
+o para un modelo más complejo de `Item`:
```Python
item: Item
```
-...and with that single declaration you get:
+...y con esa única declaración obtienes:
-* 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:
+* Soporte del editor incluyendo:
+ * Auto completado.
+ * Anotaciones de tipos.
+* Validación de datos:
+ * Errores automáticos y claros cuándo los datos son inválidos.
+ * Validación, incluso para objetos JSON profundamente anidados.
+* Conversión de datos de input: viniendo de la red a datos y tipos de Python. Leyendo desde:
* JSON.
* Path parameters.
* Query parameters.
* 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:
+ * Formularios.
+ * Archivos.
+* Conversión de datos de output: convirtiendo de datos y tipos de Python a datos para la red (como JSON):
+ * Convertir tipos de Python (`str`, `int`, `float`, `bool`, `list`, etc).
+ * Objetos `datetime`.
+ * Objetos `UUID`.
+ * Modelos de bases de datos.
+ * ...y muchos más.
+* Documentación automática e interactiva incluyendo 2 interfaces de usuario alternativas:
* 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.
+Volviendo al ejemplo de código anterior, **FastAPI** va a:
+
+* Validar que existe un `item_id` en el path para requests usando `GET` y `PUT`.
+* Validar que el `item_id` es del tipo `int` para requests de tipo `GET` y `PUT`.
+ * Si no lo es, el cliente verá un mensaje de error útil y claro.
+* Revisar si existe un query parameter opcional llamado `q` (cómo en `http://127.0.0.1:8000/items/foo?q=somequery`) para requests de tipo `GET`.
+ * Como el parámetro `q` fue declarado con `= None` es opcional.
+ * Sin el `None` sería obligatorio (cómo lo es el body en el caso con `PUT`).
+* Para requests de tipo `PUT` a `/items/{item_id}` leer el body como JSON:
+ * Revisar si tiene un atributo requerido `name` que debe ser un `str`.
+ * Revisar si tiene un atributo requerido `price` que debe ser un `float`.
+ * Revisar si tiene un atributo opcional `is_offer`, que debe ser un `bool`si está presente.
+ * Todo esto funcionaría para objetos JSON profundamente anidados.
+* Convertir de y a JSON automáticamente.
+* Documentar todo con OpenAPI que puede ser usado por:
+ * Sistemas de documentación interactiva.
+ * Sistemas de generación automática de código de cliente para muchos lenguajes.
+* Proveer directamente 2 interfaces de documentación web interactivas.
---
-We just scratched the surface, but you already get the idea of how it all works.
+Hasta ahora, escasamente vimos lo básico pero ya tienes una idea de cómo funciona.
-Try changing the line with:
+Intenta cambiando la línea a:
```Python
return {"item_name": item.name, "item_id": item_id}
```
-...from:
+...de:
```Python
... "item_name": item.name ...
```
-...to:
+...a:
```Python
... "item_price": item.price ...
```
-...and see how your editor will auto-complete the attributes and know their types:
+... y mira como el editor va a auto-completar los atributos y sabrá sus tipos:
-
+
-For a more complete example including more features, see the Tutorial - User Guide.
+Para un ejemplo más completo que incluye más características ve el Tutorial - Guía de Usuario.
-**Spoiler alert**: the tutorial - user guide includes:
+**Spoiler alert**: el Tutorial - Guía de Usuario incluye:
-* 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:
+* Declaración de **parámetros** en otros lugares diferentes cómo los: **headers**, **cookies**, **formularios** y **archivos**.
+* Cómo agregar **requisitos de validación** cómo `maximum_length` o `regex`.
+* Un sistema de **Dependency Injection** poderoso y fácil de usar.
+* Seguridad y autenticación incluyendo soporte para **OAuth2** con **JWT tokens** y **HTTP Basic** auth.
+* Técnicas más avanzadas, pero igual de fáciles, para declarar **modelos de JSON profundamente anidados** (gracias a Pydantic).
+* Muchas características extra (gracias a Starlette) como:
* **WebSockets**
* **GraphQL**
- * extremely easy tests based on `requests` and `pytest`
+ * pruebas extremadamente fáciles con `requests` y `pytest`
* **CORS**
* **Cookie Sessions**
- * ...and more.
+ * ...y mucho más.
-## Performance
+## Rendimiento
-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). (*)
+Benchmarks independientes de TechEmpower muestran que aplicaciones de **FastAPI** corriendo con Uvicorn cómo uno de los frameworks de Python más rápidos, únicamente debajo de Starlette y Uvicorn (usados internamente por FastAPI). (*)
-To understand more about it, see the section Benchmarks.
+Para entender más al respecto revisa la sección Benchmarks.
-## Optional Dependencies
+## Dependencias Opcionales
-Used by Pydantic:
+Usadas por Pydantic:
-* ujson - for faster JSON "parsing".
-* email_validator - for email validation.
+* ujson - para "parsing" de JSON más rápido.
+* email_validator - para validación de emails.
-Used by Starlette:
+Usados por Starlette:
-* 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 - Requerido si quieres usar el `TestClient`.
+* aiofiles - Requerido si quieres usar `FileResponse` o `StaticFiles`.
+* jinja2 - Requerido si quieres usar la configuración por defecto de templates.
+* python-multipart - Requerido si quieres dar soporte a "parsing" de formularios, con `request.form()`.
+* itsdangerous - Requerido para dar soporte a `SessionMiddleware`.
+* pyyaml - Requerido para dar soporte al `SchemaGenerator` de Starlette (probablemente no lo necesites con FastAPI).
+* graphene - Requerido para dar soporte a `GraphQLApp`.
+* ujson - Requerido si quieres usar `UJSONResponse`.
-Used by FastAPI / Starlette:
+Usado por FastAPI / Starlette:
-* uvicorn - for the server that loads and serves your application.
-* orjson - Required if you want to use `ORJSONResponse`.
+* uvicorn - para el servidor que carga y sirve tu aplicación.
+* orjson - Requerido si quieres usar `ORJSONResponse`.
-You can install all of these with `pip install fastapi[all]`.
+Puedes instalarlos con `pip install fastapi[all]`.
-## License
+## Licencia
-This project is licensed under the terms of the MIT license.
+Este proyecto está licenciado bajo los términos de la licencia del MIT.