# MAIN # Usamos una expresión generadora para encontrar el primer item con el ID
buscado
# Importamos la clase FastAPI para crear la aplicación web
return next((i for i in catalogo if [Link] == item_id), None)
from fastapi import FastAPI
# Definimos las rutas de actualización y eliminación de items
# ------------------------------- ------ ---
# Importamos el modelo de datos 'Item' que representa la estructura de un item
(probablemente definido en otro archivo)
from [Link] import Item # Ruta PUT para actualizar un item existente en el catálogo
@[Link]("/items/{item_id}", response_model=Item) # El endpoint devuelve el
item actualizado
# Importamos el catálogo que simula la base de datos en memoria (una lista de async def update_item(item_id: int, item: Item):
items)
# Buscamos el item en el catálogo por su ID usando la función auxiliar
from [Link] import catalogo
item_encontrado = find_item_by_id_v2(item_id)
# Si no se encontró el item, devolvemos el nuevo item (también podría lanzarse
un error 404)
# Creamos una instancia de la aplicación FastAPI
if item_encontrado is None:
app = FastAPI()
return item
# Si el item existe, encontramos su posición en la lista del catálogo
# Si queremos cambiar la URL donde se muestra la documentación automática,
posicion = [Link](item_encontrado)
podríamos descomentar la siguiente línea
# app = FastAPI(docs_url="/midocs")
# Definimos las rutas (endpoints) de la API # Reemplazamos el item antiguo por el nuevo
# Ruta raíz ("/"), que devuelve un mensaje de bienvenida al acceder al servidor catalogo[posicion] = item
@[Link]("/")
async def root():
# Devolvemos el item actualizado
return {"mensaje": "Hola Mundo"}
return item
# Ruta GET para obtener todos los items del catálogo
# Ruta DELETE para eliminar un item del catálogo
@[Link]("/items", response_model=list[Item]) # El endpoint devuelve una lista
de objetos 'Item' @[Link]("/items/{item_id}") # El endpoint devuelve un mensaje de
confirmación
async def read_items():
async def delete_item(item_id: int):
return catalogo # Retornamos el catálogo completo
# Buscamos el item en el catálogo por su ID
item_encontrado = find_item_by_id_v2(item_id)
# Ruta POST para agregar un nuevo item al catálogo
@[Link]("/items", response_model=Item) # El endpoint devuelve el item
recién creado # Si no se encuentra el item, devolvemos un mensaje de error
async def add_item(item: Item): if item_encontrado is None:
[Link](item) # Añadimos el nuevo item al catálogo (lista en return {"mensaje": "Item no encontrado"}
memoria)
return item # Devolvemos el item recién añadido
# Si el item existe, lo eliminamos del catálogo
[Link](item_encontrado)
# Funciones auxiliares para buscar items
# Devolvemos un mensaje de confirmación
# Función auxiliar para encontrar un item por su ID (método básico usando un
bucle for) return {"mensaje": "Item borrado"}
def find_item_by_id(item_id: int):
i = None
# ITEM
for i in catalogo: # Recorremos todos los elementos del catálogo
from pydantic import BaseModel
if i["id"] == item_id: # Si encontramos el item con el ID buscado
class Item(BaseModel):
break # Detenemos la búsqueda
id: int
return i # Devolvemos el item encontrado o None si no se encontró
nombre: str
precio: float
# Otra función auxiliar para buscar un item por su ID (versión optimizada usando # Resumen del Comportamiento CRUD:
la función 'next')
# Método HTTP, Ruta, Descripción
def find_item_by_id_v2(item_id: int):
# GET, /items, Devuelve todos los items del catálogo. # Ruta raíz ("/"), que devuelve un mensaje de bienvenida y renderiza la plantilla
"[Link]"
# POST, /items, Agrega un nuevo item al catálogo.
@[Link]("/", response_class=HTMLRe spon se)
# PUT, /items/{item_id}, Actualiza un item existente por su ID.
async def root(request: Request):
# DELETE, /items/{item_id}, Elimina un item del catálogo por su ID.
mensaje = "Hola mundo"
# Importamos la clase BaseModel de la biblioteca Pydantic
return [Link]("[Link]", {"request": request,
from pydantic import BaseModel
"mensaje": mensaje})
# Definimos una clase 'Item' que hereda de 'BaseModel'
class Item(BaseModel):
# Atributos de la clase 'Item' con sus tipos de datos # Ruta GET para obtener todos los items del catálogo y renderizar la plantilla
"[Link]"
id: int # Atributo 'id' de tipo entero
@[Link]("/items", response_class=HTMLResponse)
nombre: str # Atributo 'nombre' de tipo cadena de texto
async def read_items(request: Request):
precio: float # Atributo 'precio' de tipo decimal (número flotante)
return [Link]("[Link]", {"request": request,
"catalogo": catalogo})
# Importamos la clase Item definida previamente en el archivo
'src/models/[Link]'
# Ruta GET para mostrar el formulario de creación de un nuevo item y renderizar
from [Link] import Item la plantilla "[Link]"
@[Link]("/items/nuevo", response_class=HTMLResp onse)
async def add_item(request: Request):
DB
return [Link]("[Link]", {"request": request})
# Definimos una variable 'catalogo' que es una lista de objetos de tipo 'Item'
catalogo: list[Item] = [ # La anotación ': list[Item]' indica que es una lista de
objetos de tipo 'Item'
# Ruta POST para agregar un nuevo item al catálogo y redirigir a la página de
# Agregamos manualmente algunos elementos de ejemplo al catálogo items
Item(id=1, nombre="manzanas", precio=10), # Creamos un objeto Item con @[Link]("/items/nuevo", response_class=HTMLRe spon se)
id=1, nombre="manzanas", precio=10
async def add_item(request: Request, item: Annotated[Item, Form()]):
Item(id=2, nombre="peras", precio=20) # Creamos otro objeto Item con
id=2, nombre="peras", precio=20 [Link](item) # Añadimos el nuevo item al catálogo (lista en
memoria)
]
redirect_url = "/items" # URL de redirección
return RedirectResponse(url=redirect_url,
status_code=status.HTTP_303_S EE_OTHE R)
# Función auxiliar para encontrar un item por su ID en el catálogo
def find_item_by_id(item_id: int):
return next((i for i in catalogo if [Link] == item_id), None)
# Ruta GET para eliminar un item del catálogo y redirigir a la página de items
@[Link]("/items/{item_id}/borrar", response_class=HTMLRe spon se)
# Importamos las clases y funciones necesarias de FastAPI y otras bibliotecas async def delete_item(request: Request, item_id: int):
from fastapi import FastAPI, Request, Form, status item = find_item_by_id(item_id) # Buscamos el item por su ID
from [Link] import StaticFiles if item:
from [Link] import Jinja2Templates [Link](item) # Eliminamos el item del catálogo si existe
from [Link] import HTMLResponse, RedirectResponse redirect_url = "/items" # URL de redirección
from [Link] import Item return RedirectResponse(url=redirect_url,
status_code=status.HTTP_303_S EE_OTHE R)
from [Link] import catalogo
from typing import Annotated
# Creamos una instancia de la aplicación FastAPI
app = FastAPI()
# Montamos el directorio de archivos estáticos (CSS, JS, imágenes) en la ruta
"/static"
[Link]("/static", StaticFiles(directory="src/static"), name="static")
# Configuramos el directorio de plantillas Jinja2
templates = Jinja2Templates(directory="src/templates")