Características¶

Características de FastAPI¶

FastAPI te ofrece lo siguiente:

Basado en estándares abiertos¶

• OpenAPI para la creación de APIs, incluyendo declaraciones de operaciones de ruta, parámetros, cuerpos de petición, seguridad, etc.
• Documentación automática de modelos de datos con JSON Schema (ya que OpenAPI mismo está basado en JSON Schema).
• Diseñado en torno a estos estándares, después de un estudio meticuloso. En lugar de una capa añadida como ocurrencia tardía.
• Esto también permite usar la generación automática de código cliente en muchos lenguajes.

Documentación automática¶

Interfaces de usuario web interactivas para documentación y exploración de APIs. Como el framework está basado en OpenAPI, hay múltiples opciones, 2 incluidas por defecto.

• Swagger UI, con exploración interactiva, llama y prueba tu API directamente desde el navegador.

• Documentación alternativa de la API con ReDoc.

Solo Python moderno¶

Todo está basado en declaraciones estándar de tipos de Python (gracias a Pydantic). No hay nueva sintaxis que aprender. Solo Python moderno estándar.

Si necesitas un repaso de 2 minutos sobre cómo usar tipos de Python (incluso si no usas FastAPI), revisa el breve tutorial: Tipos de Python.

Escribes Python estándar con tipos:

from datetime import date

from pydantic import BaseModel

# Declare a variable as a str
# and get editor support inside the function
def main(user_id: str):
    return user_id


# A Pydantic model
class User(BaseModel):
    id: int
    name: str
    joined: date

Que luego puede ser usado así:

my_user: User = User(id=3, name="John Doe", joined="2018-07-19")

second_user_data = {
    "id": 4,
    "name": "Mary",
    "joined": "2018-11-30",
}

my_second_user: User = User(**second_user_data)

Soporte del editor¶

Todo el framework fue diseñado para ser fácil e intuitivo de usar, todas las decisiones fueron probadas en múltiples editores incluso antes de empezar el desarrollo, para asegurar la mejor experiencia de desarrollo.

En las encuestas de desarrolladores de Python, queda claro que una de las características más usadas es el "autocompletado".

Todo el framework FastAPI está diseñado para satisfacer eso. El autocompletado funciona en todas partes.

Raramente necesitarás volver a la documentación.

Así es como tu editor podría ayudarte:

• en Visual Studio Code:

• en PyCharm:

Obtendrás autocompletado en código que antes podrías haber considerado imposible. Por ejemplo, la clave price dentro de un cuerpo JSON (que podría haber estado anidado) que viene de una petición.

No más escribir nombres de claves incorrectos, yendo y viniendo entre la documentación, o desplazándote arriba y abajo para encontrar si finalmente usaste username o user_name.

Conciso¶

Tiene valores por defecto sensatos para todo, con configuraciones opcionales en todas partes. Todos los parámetros pueden ser ajustados para hacer lo que necesitas y para definir la API que necesitas.

Pero por defecto, todo "simplemente funciona".

Validación¶

• Validación para la mayoría (¿o todos?) de los tipos de datos de Python, incluyendo:

  • Objetos JSON (dict).
  • Array JSON (list) definiendo los tipos de los elementos.
  • Campos de texto (str), definiendo longitudes mínimas y máximas.
  • Números (int, float) con valores mínimos y máximos, etc.

• Validación para tipos más exóticos, como:

  • URL.
  • Email.
  • UUID.
  • ...y otros.

Toda la validación es manejada por el bien establecido y robusto Pydantic.

Seguridad y autenticación¶

Seguridad y autenticación integradas. Sin ningún compromiso con bases de datos o modelos de datos.

Todos los esquemas de seguridad definidos en OpenAPI, incluyendo:

• HTTP Basic.
• OAuth2 (también con tokens JWT). Revisa el tutorial sobre OAuth2 con JWT.
• API keys in:
  • Headers.
  • Parámetros de query.
  • Cookies, etc.

Más todas las características de seguridad de Starlette (incluyendo cookies de sesión).

Todo construido como herramientas y componentes reutilizables que son fáciles de integrar con tus sistemas, almacenes de datos, bases de datos relacionales y NoSQL, etc.

Dependency Injection¶

FastAPI incluye un sistema de Dependency Injection extremadamente fácil de usar, pero extremadamente potente.

• Incluso las dependencias pueden tener dependencias, creando una jerarquía o "grafo" de dependencias.
• Todo manejado automáticamente por el framework.
• Todas las dependencias pueden requerir datos de las peticiones y aumentar las restricciones de la operación de ruta y la documentación automática.
• Validación automática incluso para parámetros de operaciones de ruta definidos en las dependencias.
• Soporte para sistemas complejos de autenticación de usuarios, conexiones a bases de datos, etc.
• Sin compromisos con bases de datos, frontends, etc. Pero fácil integración con todos ellos.

"Plug-ins" ilimitados¶

O, en otras palabras, no necesitan, importa y usa el código que necesitas.

Cualquier integración está diseñada para ser tan simple de usar (con dependencias) que puedes crear un "plug-in" para tu aplicación en 2 líneas de código usando la misma estructura y sintaxis usada para tus operaciones de ruta.

Probado¶

• 100% test coverage.
• Base de código 100% anotada con tipos.
• Usado en aplicaciones en producción.

Características de Starlette¶

FastAPI es totalmente compatible con (y está basado en) Starlette. Así que, cualquier código adicional de Starlette que tengas, también funcionará.

FastAPI es en realidad una subclase de Starlette. Así que, si ya conoces o usas Starlette, la mayoría de la funcionalidad funcionará de la misma manera.

Con FastAPI obtienes todas las características de Starlette (ya que FastAPI es simplemente Starlette con esteroides):

• Rendimiento seriamente impresionante. Es uno de los frameworks de Python más rápidos disponibles, a la par con NodeJS y Go.
• Soporte de WebSocket.
• Tareas en segundo plano dentro del proceso.
• Eventos de startup y shutdown.
• Cliente de pruebas construido sobre HTTPX.
• CORS, GZip, Archivos estáticos, Respuestas de streaming.
• Soporte de Sesión y Cookie.
• 100% de cobertura de tests.
• 100% del código base anotado con tipos.

Características de Pydantic¶

FastAPI es totalmente compatible con (y está basado en) Pydantic. Así que, cualquier código adicional de Pydantic que tengas, también funcionará.

Incluyendo librerías externas también basadas en Pydantic, como ORMs y ODMs para bases de datos.

Esto también significa que en muchos casos puedes pasar el mismo objeto que obtienes de una petición directamente a la base de datos, ya que todo es validado automáticamente.

Lo mismo aplica en sentido contrario, en muchos casos puedes simplemente pasar el objeto que obtienes de la base de datos directamente al cliente.

Con FastAPI obtienes todas las características de Pydantic (ya que FastAPI está basado en Pydantic para todo el manejo de datos):

• No brainfuck:
  • No hay que aprender un nuevo micro-lenguaje de definición de esquemas.
  • Si conoces los tipos de Python sabes cómo usar Pydantic.
• Plays nicely with your IDE/linter/brain:
  • Como las estructuras de datos de pydantic son simplemente instancias de clases que defines; el autocompletado, linting, mypy y tu intuición deberían funcionar correctamente con tus datos validados.
• Validate complex structures:
  • Uso de modelos jerárquicos de Pydantic, List y Dict del typing de Python, etc.
  • Y los validadores permiten que los esquemas de datos complejos sean definidos, verificados y documentados de forma clara y sencilla como JSON Schema.
  • Puedes tener objetos JSON anidados profundamente y tenerlos todos validados y anotados.
• Extensible:
  • Pydantic permite definir tipos de datos personalizados o puedes extender la validación con métodos en un modelo decorado con el decorador validator.
• 100% de cobertura de tests.