feat: translate comments, docstrings, and log messages to Spanish.

app/main.py

@@ -1,17 +1,17 @@
 """
-Application entry point.
+Punto de entrada de la aplicación.
 
-Initializes the FastAPI application, sets up logging, database, 
-and defines the main API endpoints.
+Inicializa la aplicación FastAPI, configura el registro, la base de datos
+y define los principales endpoints de la API.
 """
 import logging
 from fastapi import FastAPI, Depends, HTTPException
 from sqlalchemy.orm import Session
 
-# It's crucial to set up the config before other imports
+# Es crucial configurar la configuración antes de otras importaciones
 from app.config import config
 
-# Now, set up logging based on the config
+# Ahora, configurar el registro basado en la configuración
 logging.basicConfig(level=config.LOG_LEVEL.upper())
 logger = logging.getLogger(__name__)
 
@@ -20,46 +20,46 @@ from app.schema.base import RawInput
 from app.router import process_expense_input
 from app.persistence import repositories, db
 
-# Create database tables on startup
-# This is simple, but for production, you'd use migrations (e.g., Alembic)
+# Crear tablas de base de datos al inicio
+# Esto es simple, pero para producción, usarías migraciones (ej. Alembic)
 repositories.create_tables()
 
-# Initialize the FastAPI app
+# Inicializar la aplicación FastAPI
 app = FastAPI(
-    title="Telegram Expenses Bot API",
-    description="Processes and manages expense data from various sources.",
+    title="API del Bot de Gastos de Telegram",
+    description="Procesa y gestiona datos de gastos de diversas fuentes.",
     version="1.0.0"
 )
 
 @app.on_event("startup")
 async def startup_event():
-    logger.info("Application startup complete.")
-    logger.info(f"Log level is set to: {config.LOG_LEVEL.upper()}")
+    logger.info("Inicio de la aplicación completado.")
+    logger.info(f"El nivel de registro está establecido en: {config.LOG_LEVEL.upper()}")
 
-@app.get("/", tags=["Status"])
+@app.get("/", tags=["Estado"])
 async def root():
-    """Health check endpoint."""
-    return {"message": "Telegram Expenses Bot API is running."}
+    """Endpoint de verificación de salud."""
+    return {"message": "La API del Bot de Gastos de Telegram está en ejecución."}
 
 @app.post("/webhook/telegram", tags=["Webhooks"])
 async def process_telegram_update(request: dict):
     """
-    This endpoint would receive updates directly from a Telegram webhook.
-    It needs to be implemented to parse the Telegram Update object and
-    convert it into our internal RawInput model.
+    Este endpoint recibiría actualizaciones directamente de un webhook de Telegram.
+    Necesita ser implementado para analizar el objeto Update de Telegram y
+    convertirlo en nuestro modelo RawInput interno.
     """
-    logger.info(f"Received Telegram update: {request}")
-    # TODO: Implement a parser for the Telegram Update object.
-    # For now, this is a placeholder.
-    return {"status": "received", "message": "Telegram webhook handler not fully implemented."}
+    logger.info(f"Actualización de Telegram recibida: {request}")
+    # TODO: Implementar un analizador para el objeto Update de Telegram.
+    # Por ahora, esto es un marcador de posición.
+    return {"status": "received", "message": "El manejador de webhook de Telegram no está completamente implementado."}
 
-@app.post("/process-expense", tags=["Processing"])
+@app.post("/process-expense", tags=["Procesamiento"])
 async def process_expense(raw_input: RawInput, db_session: Session = Depends(db.get_db)):
     """
-    Receives raw expense data, processes it through the full pipeline,
-    and returns the result.
+    Recibe datos de gastos sin procesar, los procesa a través del pipeline completo
+    y devuelve el resultado.
     """
-    logger.info(f"Received raw input for processing: {raw_input.dict()}")
+    logger.info(f"Entrada sin procesar recibida para procesamiento: {raw_input.dict()}")
     
     try:
         result = process_expense_input(db=db_session, raw_input=raw_input)
@@ -67,18 +67,18 @@ async def process_expense(raw_input: RawInput, db_session: Session = Depends(db.
         if result:
             return {"status": "success", "expense_id": result.id}
         else:
-            # This could happen if confidence is low or an error occurred
+            # Esto podría suceder si la confianza es baja o ocurrió un error
             raise HTTPException(
                 status_code=400, 
-                detail="Failed to process expense. It may require manual review or had invalid data."
+                detail="Error al procesar el gasto. Puede requerir revisión manual o tenía datos inválidos."
             )
 
     except ValueError as e:
-        logger.error(f"Validation error: {e}")
+        logger.error(f"Error de validación: {e}")
         raise HTTPException(status_code=422, detail=str(e))
     except Exception as e:
-        logger.critical(f"An unexpected error occurred in the processing pipeline: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="An internal server error occurred.")
+        logger.critical(f"Ocurrió un error inesperado en el pipeline de procesamiento: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Ocurrió un error interno del servidor.")
 
-# To run this app:
+# Para ejecutar esta aplicación:
 # uvicorn app.main:app --reload