Funcionalidades

Funcionalidades de FastAPI

FastAPI te ofrece lo siguiente:

Basado en estándares abiertos

• OpenAPI para la creación de APIs, incluyendo declaraciones de path operations, parámetros, request bodies, seguridad, etc.
• Documentación automática de modelos de datos con JSON Schema (ya que OpenAPI en sí mismo está basado en JSON Schema).
• Diseñado alrededor de estos estándares, tras un estudio meticuloso. En lugar de ser una capa adicional.
• Esto también permite el uso de generación de código cliente automática en muchos idiomas.

Documentación automática

Interfaces web de documentación y exploración de APIs interactivas. 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 API con ReDoc.

Solo Python moderno

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

Si necesitas un repaso de 2 minutos sobre cómo usar tipos en Python (aunque no uses FastAPI), revisa el tutorial corto: Tipos en Python.

Escribes Python estándar con tipos:

from datetime import date

from pydantic import BaseModel

# Declara una variable como un str
# y obtiene soporte del editor dentro de la función
def main(user_id: str):
    return user_id


# Un modelo de Pydantic
class User(BaseModel):
    id: int
    name: str
    joined: date

Que luego puede ser usado como:

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)

Información

**second_user_data significa:

Pasa las claves y valores del dict second_user_data directamente como argumentos de clave-valor, equivalente a: User(id=4, name="Mary", joined="2018-11-30")

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 comenzar el desarrollo, para asegurar la mejor experiencia de desarrollo.

En las encuestas a desarrolladores de Python, es claro que una de las funcionalidades más usadas es el "autocompletado".

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

Rara vez necesitarás regresar a la documentación.

Aquí está cómo tu editor podría ayudarte:

• en Visual Studio Code:

• en PyCharm:

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

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

Breve

Tiene valores predeterminados sensatos para todo, con configuraciones opcionales en todas partes. Todos los parámetros se pueden ajustar finamente para hacer lo que necesitas y para definir el API que necesitas.

Pero por defecto, todo "simplemente funciona".

Validación

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

  • Objetos JSON (dict).
  • Array JSON (list) definiendo tipos de elementos.
  • Campos de cadena de caracteres (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 Pydantic, una herramienta bien establecida y robusta.

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 Básico.
• OAuth2 (también con tokens JWT). Revisa el tutorial sobre OAuth2 con JWT.
• API keys en:
  • Headers.
  • Parámetros de query.
  • Cookies, etc.

Además de 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.

Inyección de dependencias

FastAPI incluye un sistema de Inyección de Dependencias extremadamente fácil de usar, pero extremadamente potente.

• Incluso las dependencias pueden tener dependencias, creando una jerarquía o "gráfico de dependencias".
• Todo manejado automáticamente por el framework.
• Todas las dependencias pueden requerir datos de los requests y aumentar las restricciones de la path operation y la documentación automática.
• Validación automática incluso para los parámetros de path operation definidos en las dependencias.
• Soporte para sistemas de autenticación de usuario complejos, 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 de otra manera, no hay necesidad de ellos, 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 utilizada para tus path operations.

Probado

• 100% de cobertura de tests.
• Código completamente anotado con tipos.
• Usado en aplicaciones en producción.

Funcionalidades 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 las funcionalidades funcionarán de la misma manera.

Con FastAPI obtienes todas las funcionalidades de Starlette (ya que FastAPI es simplemente Starlette potenciado):

• Rendimiento seriamente impresionante. Es uno de los frameworks de Python más rápidos disponibles, a la par de NodeJS y Go.
• Soporte para WebSocket.
• Tareas en segundo plano en el mismo proceso.
• Eventos de inicio y apagado.
• Cliente de prueba basado en HTTPX.
• CORS, GZip, archivos estáticos, responses en streaming.
• Soporte para Session y Cookie.
• Cobertura de tests del 100%.
• Código completamente anotado con tipos.

Funcionalidades de Pydantic

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

Incluyendo paquetes externos también basados en Pydantic, como ORMs, ODMs para bases de datos.

Esto también significa que, en muchos casos, puedes pasar el mismo objeto que obtienes de un request directamente a la base de datos, ya que todo se valida automáticamente.

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

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

• Sin complicaciones:
  • Sin micro-lenguaje de definición de esquemas nuevo que aprender.
  • Si conoces los tipos en Python sabes cómo usar Pydantic.
• Se lleva bien con tu IDE/linter/cerebro:
  • Porque las estructuras de datos de pydantic son solo instances de clases que defines; autocompletado, linting, mypy y tu intuición deberían funcionar correctamente con tus datos validados.
• Valida estructuras complejas:
  • Uso de modelos jerárquicos de Pydantic, List y Dict de typing de Python, etc.
  • Y los validadores permiten definir, verificar y documentar de manera clara y fácil esquemas de datos complejos como JSON Schema.
  • Puedes tener objetos JSON profundamente anidados y validarlos todos y anotarlos.
• Extensible:
  • Pydantic permite definir tipos de datos personalizados o puedes extender la validación con métodos en un modelo decorados con el decorador validator.
• Cobertura de tests del 100%.