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 de FastAPI, sus características y cómo usarlo de manera efectiva. Más adelante en este artículo, también analizaremos IronPDF un paquete de generación de PDF para Python de IronSoftware.

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]"

pip install fastapi
pip install "uvicorn[standard]"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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}

from fastapi import FastAPI app = FastAPI() app.get("/") def read_root(): Return
If True Then
	"Hello": "World"
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@app.@get("/items/{item_id}") # @with query parameters def read_item(item_id: int, q: str = None): Return
'{
''INSTANT VB TODO TASK: The following line uses invalid syntax:
''	"item_id": item_id, "q": q}

Para ejecutar la aplicación, use Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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"}

404, detail="Item not found"
status_code=404, detail
404, detail="Item not found"
status_code=404, detail
404, detail="Item not found"
status_code=404, detail
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: 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
item Return item app.get("/items/{item_id}") # [optional] str query parameter def read_item(item_id:= Integer): if item_id [not] in items: raise HTTPException(status_code) Return items(item_id) app.put("/items/{item_id}") # [with] path parameters def update_item(item_id: Integer, item: Item): if item_id [not] in items: raise HTTPException(status_code) items(item_id) = item Return item app.delete("/items/{item_id}") def delete_item(item_id: Integer): if item_id [not] in items: raise HTTPException(status_code) del items(item_id) Return
If True Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: 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) 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) items[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:= Integer): if item_id [not] in items: raise HTTPException(status_code) Return items(item_id) app.put("/items/{item_id}") # [with] path parameters def update_item(item_id: Integer, item: Item): if item_id [not] in items: raise HTTPException(status_code) items(item_id)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI, HTTPException app = FastAPI() items = {} @app.post("/items/") def create_item(item: Item): item_id = len(items) + 1 items[item_id]
{} app.post("/items/") def create_item(item:= Item): item_id = len(items) + 1 items(item_id)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI, HTTPException app = FastAPI() items = {} @app.post("/items/") def create_item(item: Item): item_id
FastAPI() items = {} app.post("/items/") def create_item(item:= Item): item_id
from fastapi import FastAPI, HTTPException app = FastAPI() items
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'	"message": "Item deleted"}

Presentación de IronPDF

IronPDF es 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

pip install fastapi
pip install ironPDF

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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

#Apply your license key
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI from fastapi.responses import FileResponse from ironpdf import * License.LicenseKey = "key" app = FastAPI() @app.get("/") def read_root(): return
"key" app = FastAPI() app.get("/") def read_root(): Return
If True Then
From fastapi import FastAPI From fastapi.responses import FileResponse From ironpdf import * License.LicenseKey = "key" app
	"Hello": "IronPDF"
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@app.@get("/items/{item_id}") # @with query parameters def read_item(item_id: int, q: str = None): Return
'{
'	"item_id": item_id, "q": q
'}
#Create a PDF from a HTML string using Python
	#Export to a file or Stream
	#To view the file in the browser, use "inline" for the media_type
	#Create a FileResponse object with the file path, media type and headers
	#Return the FileResponse object
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'@app.@get("/pdf") async def get_pdf(greet1: str = None,greet2: str = None): renderer = ChromePdfRenderer() 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) pdf.SaveAs("fastapi.pdf") headers = { "Content-Disposition": "inline; filename=sample.pdf" } response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers) 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 un prueba gratuita clave 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"

IRON VB CONVERTER ERROR developers@ironsoftware.com

Conclusión

FastAPI es 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.

IronPDF es 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.