FastAPI Python (Cómo Funciona Para Desarrolladores)

Introducción

FastAPIes un marco web moderno y de alto rendimiento para construir APIs con Python. Está diseñado para ser fácil de usar y aprender, mientras ofrece características potentes como la validación automática, la serialización y la documentación interactiva automática de la API. Además, funciona con cualquier motor de plantillas y te permite usar cualquier configuración de plantilla predeterminada que necesites para tu proyecto.

Vamos a profundizar en los detalles deFastAPI, sus características y cómo usarlo de manera efectiva. Más adelante en este artículo, también analizaremosIronPDFun paquete de generación de PDF para Python de Iron Software.

Características clave de FastAPI

1. Alto Rendimiento: FastAPI es uno de los frameworks de Python más rápidos disponibles, comparable a Node.js y Go, gracias a su uso de Starlette para las partes web y Pydantic para las partes de datos.

2. Facilidad de uso: Está diseñado para ser intuitivo y reducir el tiempo dedicado a leer documentación. El framework utiliza pistas de tipo estándar de Python para la validación y serialización de datos.

3. Documentación interactiva automática: FastAPI genera automáticamente documentación interactiva de la API utilizando OpenAPI y JSON Schema, accesible a través de /docs.(Swagger UI)y /redoc(ReDoc)y la actualización de la documentación API interactiva significa que esta documentación se actualiza automáticamente. La actualización de la documentación API alternativa también reflejará esto.

4. Soporte del Editor: Excelente soporte para la autocompletación de código y comprobación de tipos en editores como VS Code, haciendo que el desarrollo sea más rápido y reduzca errores.

5. Basado en estándares: Está basado en(y completamente compatible con)los estándares abiertos para APIs: OpenAPI y JSON Schema.

Instalación

Puedes instalar FastAPI y Uvicorn (un servidor ASGI) usando pip:

pip install fastapi
pip install "uvicorn[standard]"

Creación de tu primera aplicación FastAPI

Aquí tienes un ejemplo sencillo para comenzar con FastAPI y exponer datos de Python a través de una interfaz de usuario:

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "World"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "World"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Para ejecutar la aplicación, use Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

Este comando iniciará un servidor de desarrollo y recargará automáticamente para los cambios en el código. Puede acceder a la documentación interactiva de la API en http://127.0.0.1:8000/docs.

Funciones avanzadas

FastAPI es compatible con una amplia gama de funciones avanzadas, lo que lo hace adecuado para aplicaciones complejas:

1. Inyección de Dependencias: FastAPI ofrece un potente sistema de inyección de dependencias que te permite gestionar las dependencias de manera limpia y eficiente.

2. Tareas en segundo plano: Se pueden definir tareas en segundo plano para ejecutar después de devolver una respuesta, útiles para tareas como enviar correos electrónicos o procesar datos.

3. WebSockets: FastAPI admite WebSockets, lo que permite la comunicación en tiempo real entre el cliente y el servidor.

4. Seguridad: FastAPI incluye herramientas para manejar la seguridad, incluyendo OAuth2, tokens JWT y más.

5. Integración de base de datos: FastAPI se puede integrar fácilmente con bases de datos utilizando bibliotecas como SQLAlchemy o Tortoise-ORM.

Ejemplo: Creación de una API CRUD

Construyamos un CRUD simple(Crear, Leer, Actualizar, Suprimir)API para gestionar elementos.

1. Definir el modelo de datos:

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

1. Crear la aplicación FastAPI:

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

Presentación de IronPDF

IronPDFes una potente biblioteca de Python diseñada para crear, editar y firmar PDFs a partir de HTML, CSS, imágenes y JavaScript. Ofrece un rendimiento de nivel comercial con un bajo consumo de memoria. Las características clave incluyen:

Conversión de HTML a PDF

Convierta archivos HTML, cadenas HTML y URL en PDF. Por ejemplo, renderiza una página web como PDF utilizando el renderizador de PDF de Chrome.

Soporte multiplataforma

Compatible con varias plataformas .NET, incluidas .NET Core, .NET Standard y .NET Framework. Es compatible con Windows, Linux y macOS.

Edición y firma

Establezca propiedades, añada seguridad con contraseñas y permisos, y aplique firmas digitales a sus PDF.

Plantillas de página y configuración

Personalice los PDF con encabezados, pies de página, números de página y márgenes ajustables. Admite diseños adaptables y tamaños de papel personalizados.

Cumplimiento de las normas

Cumple estándares PDF como PDF/A y PDF/UA. Admite la codificación de caracteres UTF-8 y gestiona activos como imágenes, CSS y fuentes.

Generar documentos PDF utilizando IronPDF y FastAPI

pip install fastapi
pip install ironPDF

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

Código Explicación

Este fragmento de código demuestra la integración de IronPDF con FastAPI para generar dinámicamente documentos PDF basados en las entradas del usuario y servirlos como una respuesta descargable.

1. Configuración de la clave de licencia: Aplica la clave de licencia de IronPDF para habilitar sus funciones.

2. Inicialización de FastAPI: Inicializa una instancia de FastAPI(app)para manejar solicitudes HTTP. 3. Manejadores de Rutas Básicas: `read_root(): Responde con un mensaje JSON simple que indica "Hello IronPDF" al acceder a la URL raíz(\/`). `read_item()`**: Acepta un parámetro de ruta `item_id` y un parámetro de consulta opcional `q`. Devuelve una respuesta JSON con estos parámetros de función.

3. Ruta de Generación de PDF(`/pdf`): \get_pdf()`**:

   • Esta función asíncrona gestiona las solicitudes GET al punto de acceso `/pdf` con un parámetro de consulta opcional llamado(greet1 y greet2).
   • Construye una cadena HTML(\Contenido)que incluye: Un encabezado que indique el origen y propósito del documento. Un párrafo que demuestra la generación de PDF utilizando entradas del usuario.(greet1 y greet2). Utiliza `ChromePdfRenderer()` de IronPDF para renderizar el contenido HTML en un PDF(`pdf = renderer.RenderHtmlAsPdf(contenido)`).
   • Guarda el PDF generado como "fastapi.pdf"(`pdf.SaveAs("fastapi.pdf")`).5. Sirviendo el PDF:
   • Configura las cabeceras de respuesta para especificar que el PDF debe ser visualizado en línea en el navegador(`"Content-Disposition": "inline; filename=sample.pdf"`).
   • Crea un objeto FileResponse que apunta al archivo PDF generado con el tipo de medio adecuado(`"application/pdf"`).
   • Devuelve el objeto `FileResponse`, que inicia la descarga del documento PDF cuando se accede al endpoint `/pdf`.

   Este fragmento de código ilustra cómo IronPDF se puede integrar perfectamente con FastAPI para generar y servir dinámicamente documentos PDF basados en las entradas del usuario. Muestra la capacidad de convertir contenido HTML en PDFs, haciéndolo adecuado para aplicaciones que requieren generación y entrega de documentos sobre la marcha a través de HTTP.

Salida

A continuación se muestra la salida de Swagger generada a partir de las API.

PDF

Licencia IronPDF

IronPDF se ejecuta con la clave de licencia para Python. IronPDF for Python ofrece unprueba gratuitaclave de licencia para permitir a los usuarios probar las características antes de la compra.

Coloque la clave de licencia al inicio del script antes de usar el paquete IronPDF:

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

Conclusión

FastAPIes un framework potente y fácil de usar para crear APIs en Python. FastAPI tiene un alto rendimiento, documentación automática y características avanzadas que lo convierten en una excelente opción tanto para principiantes como para desarrolladores experimentados. Ya sea que estés desarrollando una API simple o una aplicación web compleja, FastAPI proporciona las herramientas que necesitas para tener éxito.

IronPDFes una biblioteca robusta de Python para crear, manipular y renderizar documentos PDF a partir de contenido HTML. Ofrece funciones como conversión de HTML a PDF, creación de formularios interactivos, manipulación de PDF(fusión, división), y extracción de texto. Ideal para generar PDFs dinámicos con facilidad e integrarse en diversas aplicaciones de Python.