update docstrings to Spanish

Author: madebygps

examples/spanish/agent_mcp_local.py

@@ -44,7 +44,7 @@
 
 
 async def main() -> None:
-    """Run an agent connected to a local MCP server to log expenses."""
+    """Ejecuta un agente conectado a un servidor MCP local para registrar gastos."""
     async with (
         MCPStreamableHTTPTool(name="Expenses MCP Server", url=MCP_SERVER_URL) as mcp_server,
         ChatAgent(

examples/spanish/agent_mcp_remote.py

@@ -42,7 +42,7 @@
 
 
 async def main() -> None:
-    """Run an agent that uses a remote MCP server (Microsoft Learn) to answer documentation questions."""
+    """Ejecuta un agente que usa un servidor MCP remoto (Microsoft Learn) para responder preguntas de documentación."""
     async with (
         MCPStreamableHTTPTool(
             name="Microsoft Learn MCP",

examples/spanish/agent_middleware.py

@@ -1,39 +1,39 @@
 """
-Middleware flow diagram:
+Diagrama de flujo del middleware:
 
- agent.run("user message")
+ agent.run("mensaje del usuario")
  │
  ▼
  ┌─────────────────────────────────────────────┐
  │         Agent Middleware                    │
- │  (timing, blocking, logging)                │
+ │  (temporización, bloqueo, registro)         │
  │                                             │
  │  ┌───────────────────────────────────────┐  │
  │  │       Chat Middleware                 │  │
- │  │  (logging, message counting)          │  │
+ │  │  (registro, conteo de mensajes)       │  │
  │  │                                       │  │
  │  │        ┌──────────────┐               │  │
- │  │        │  AI Model    │               │  │
+ │  │        │  Modelo IA   │               │  │
  │  │        └──────┬───────┘               │  │
- │  │               │ function calls        │  │
+ │  │               │ llamadas a funciones  │  │
  │  │               ▼                       │  │
  │  │  ┌──────────────────────────────────┐ │  │
  │  │  │   Function Middleware           │ │  │
- │  │  │  (logging, timing)              │ │  │
+ │  │  │  (registro, temporización)       │ │  │
  │  │  │                                  │ │  │
  │  │  │  get_weather(), get_date(), ...  │ │  │
  │  │  └──────────────────────────────────┘ │  │
  │  │               │                       │  │
  │  │               ▼                       │  │
  │  │        ┌──────────────┐               │  │
- │  │        │  AI Model    │               │  │
- │  │        │ (final resp) │               │  │
+ │  │        │  Modelo IA   │               │  │
+ │  │        │ (resp final) │               │  │
  │  │        └──────────────┘               │  │
  │  └───────────────────────────────────────┘  │
  └─────────────────────────────────────────────┘
  │
  ▼
- response
+ respuesta
 """
 
 import asyncio
@@ -100,7 +100,7 @@
 def get_weather(
     city: Annotated[str, Field(description="The city to get the weather for.")],
 ) -> dict:
-    """Return weather data for a given city, with temperature and description."""
+    """Devuelve datos del clima para una ciudad dada, con temperatura y descripción."""
     logger.info(f"Obteniendo clima para {city}")
     if random.random() < 0.05:
         return {"temperature": 22, "description": "Soleado"}
@@ -109,7 +109,7 @@ def get_weather(
 
 
 def get_current_date() -> str:
-    """Get the current system date as text in YYYY-MM-DD format."""
+    """Obtiene la fecha actual del sistema en texto con formato YYYY-MM-DD."""
     logger.info("Obteniendo fecha actual")
     return datetime.now().strftime("%Y-%m-%d")
 
@@ -121,7 +121,7 @@ async def timing_agent_middleware(
     context: AgentRunContext,
     next: Callable[[AgentRunContext], Awaitable[None]],
 ) -> None:
-    """Agent middleware that logs execution time."""
+    """Middleware de agente que registra el tiempo de ejecución."""
     start = time.perf_counter()
     logger.info("[⏲️ Temporización][ Agent Middleware] Iniciando ejecución del agente")
 
@@ -135,7 +135,7 @@ async def logging_function_middleware(
     context: FunctionInvocationContext,
     next: Callable[[FunctionInvocationContext], Awaitable[None]],
 ) -> None:
-    """Function middleware that logs function calls and results."""
+    """Middleware de función que registra llamadas y resultados."""
     logger.info(
         f"[🪵 Registro][ Function Middleware] Llamando a {context.function.name} con args: {context.arguments}"
     )
@@ -149,7 +149,7 @@ async def logging_chat_middleware(
     context: ChatContext,
     next: Callable[[ChatContext], Awaitable[None]],
 ) -> None:
-    """Chat middleware that logs interactions with the AI."""
+    """Middleware de chat que registra interacciones con la IA."""
     logger.info(f"[💬 Registro][ Chat Middleware] Enviando {len(context.messages)} mensajes a la IA")
 
     await next(context)
@@ -161,18 +161,18 @@ async def logging_chat_middleware(
 
 
 class BlockingAgentMiddleware(AgentMiddleware):
-    """Agent middleware that blocks requests with forbidden words."""
+    """Middleware de agente que bloquea solicitudes con palabras prohibidas."""
 
     def __init__(self, blocked_words: list[str]) -> None:
-        """Initialize with a list of words that should be blocked."""
+        """Inicializa con una lista de palabras que deben ser bloqueadas."""
         self.blocked_words = blocked_words
 
     async def process(
         self,
         context: AgentRunContext,
         next: Callable[[AgentRunContext], Awaitable[None]],
     ) -> None:
-        """Check messages for blocked content and terminate if found."""
+        """Verifica mensajes con contenido bloqueado y termina si lo encuentra."""
         last_message = context.messages[-1] if context.messages else None
         if last_message and last_message.text:
             for word in self.blocked_words:
@@ -192,14 +192,14 @@ async def process(
 
 
 class TimingFunctionMiddleware(FunctionMiddleware):
-    """Function middleware that measures each function call execution time."""
+    """Middleware de función que mide el tiempo de ejecución de cada llamada."""
 
     async def process(
         self,
         context: FunctionInvocationContext,
         next: Callable[[FunctionInvocationContext], Awaitable[None]],
     ) -> None:
-        """Measure function execution time and log the duration."""
+        """Mide el tiempo de ejecución de la función y registra la duración."""
         start = time.perf_counter()
         logger.info(f"[⌚️ Temporización][ Function Middleware] Iniciando {context.function.name}")
 
@@ -210,18 +210,18 @@ async def process(
 
 
 class MessageCountChatMiddleware(ChatMiddleware):
-    """Chat middleware that counts total messages sent to the AI."""
+    """Middleware de chat que cuenta el total de mensajes enviados a la IA."""
 
     def __init__(self) -> None:
-        """Initialize the message counter."""
+        """Inicializa el contador de mensajes."""
         self.total_messages = 0
 
     async def process(
         self,
         context: ChatContext,
         next: Callable[[ChatContext], Awaitable[None]],
     ) -> None:
-        """Count messages and log the running total."""
+        """Cuenta los mensajes y registra el total acumulado."""
         self.total_messages += len(context.messages)
         logger.info(
             "[🔢 Conteo][ Chat Middleware] Mensajes en esta solicitud: %s, total hasta ahora: %s",
@@ -262,7 +262,7 @@ async def process(
 
 
 async def main() -> None:
-    """Run the agent with different inputs to demonstrate middleware behavior."""
+    """Ejecuta el agente con diferentes entradas para demostrar el comportamiento del middleware."""
     # Solicitud normal - todo el middleware se ejecuta
     logger.info("=== Solicitud Normal ===")
     response = await agent.run("¿Cómo estará el clima este fin de semana en Madrid?")
@@ -280,7 +280,7 @@ async def extra_agent_middleware(
         context: AgentRunContext,
         next: Callable[[AgentRunContext], Awaitable[None]],
     ) -> None:
-        """Execution middleware that only applies to this specific run."""
+        """Middleware de ejecución que solo aplica a esta ejecución específica."""
         logger.info("[🏃🏽‍♀️ Execution Middleware] Este middleware solo aplica a esta ejecución")
         await next(context)
         logger.info("[🏃🏽‍♀️ Execution Middleware] Ejecución completada")

examples/spanish/agent_supervisor.py

@@ -54,7 +54,7 @@ def get_weather(
     city: Annotated[str, Field(description="City to fetch the weather for.")],
     date: Annotated[str, Field(description="Date (YYYY-MM-DD) to fetch the weather for.")],
 ) -> dict:
-    """Return weather data for a given city and date."""
+    """Devuelve datos meteorológicos para una ciudad y fecha dadas."""
     logger.info(f"Obteniendo el clima para {city} en {date}")
     if random.random() < 0.05:
         return {"temperature": 72, "description": "Soleado"}
@@ -66,7 +66,7 @@ def get_activities(
     city: Annotated[str, Field(description="City to fetch activities for.")],
     date: Annotated[str, Field(description="Date (YYYY-MM-DD) to fetch activities for.")],
 ) -> list[dict]:
-    """Return a list of activities for the given city and date."""
+    """Devuelve una lista de actividades para la ciudad y la fecha indicadas."""
     logger.info(f"Obteniendo actividades para {city} en {date}")
     return [
         {"name": "Senderismo", "location": city},
@@ -76,7 +76,7 @@ def get_activities(
 
 
 def get_current_date() -> str:
-    """Get the current system date (YYYY-MM-DD)."""
+    """Obtiene la fecha actual del sistema (YYYY-MM-DD)."""
     logger.info("Obteniendo la fecha actual")
     return datetime.now().strftime("%Y-%m-%d")
 
@@ -93,7 +93,7 @@ def get_current_date() -> str:
 
 
 async def plan_weekend(query: str) -> str:
-    """Plan a weekend from the user query and return the final response."""
+    """Planifica un fin de semana según la consulta del usuario y devuelve la respuesta final."""
     logger.info("Herramienta: plan_weekend invocada")
     response = await weekend_agent.run(query)
     return response.text
@@ -107,7 +107,7 @@ async def plan_weekend(query: str) -> str:
 def find_recipes(
     query: Annotated[str, Field(description="User query or desired meal/ingredient")],
 ) -> list[dict]:
-    """Return recipes (JSON) based on a query."""
+    """Devuelve recetas (JSON) basadas en una consulta."""
     logger.info(f"Buscando recetas para '{query}'")
     if "pasta" in query.lower():
         recipes = [
@@ -141,7 +141,7 @@ def find_recipes(
 
 
 def check_fridge() -> list[str]:
-    """Return a JSON list of ingredients currently in the fridge."""
+    """Devuelve una lista JSON de ingredientes actualmente en el refrigerador."""
     logger.info("Revisando los ingredientes del refrigerador")
     if random.random() < 0.5:
         items = ["pasta", "salsa de tomate", "pimientos", "aceite de oliva"]
@@ -162,7 +162,7 @@ def check_fridge() -> list[str]:
 
 
 async def plan_meal(query: str) -> str:
-    """Plan a meal from the user query and return the final response."""
+    """Planifica una comida según la consulta del usuario y devuelve la respuesta final."""
     logger.info("Herramienta: plan_meal invocada")
     response = await meal_agent.run(query)
     return response.text

examples/spanish/agent_tool.py

@@ -46,7 +46,7 @@
 def get_weather(
     city: Annotated[str, Field(description="City name")],
 ) -> dict:
-    """Return weather data for a city: temperature and description."""
+    """Devuelve datos meteorológicos para una ciudad: temperatura y descripción."""
     logger.info(f"Obteniendo el clima para {city}")
     if random.random() < 0.05:
         return {

examples/spanish/agent_tools.py

@@ -48,7 +48,7 @@
 def get_weather(
     city: Annotated[str, Field(description="City to fetch the weather for.")],
 ) -> dict:
-    """Return weather data for a city: temperature and description."""
+    """Devuelve datos meteorológicos para una ciudad: temperatura y descripción."""
     logger.info(f"Obteniendo el clima para {city}")
     if random.random() < 0.05:
         return {
@@ -66,7 +66,7 @@ def get_activities(
     city: Annotated[str, Field(description="City to fetch activities for.")],
     date: Annotated[str, Field(description="Date (YYYY-MM-DD) to fetch activities for.")],
 ) -> list[dict]:
-    """Return a list of activities for a given city and date."""
+    """Devuelve una lista de actividades para una ciudad y fecha dadas."""
     logger.info(f"Obteniendo actividades para {city} en {date}")
     return [
         {"name": "Senderismo", "location": city},
@@ -76,7 +76,7 @@ def get_activities(
 
 
 def get_current_date() -> str:
-    """Get the current system date in YYYY-MM-DD format."""
+    """Obtiene la fecha actual del sistema en formato YYYY-MM-DD."""
     logger.info("Obteniendo la fecha actual")
     return datetime.now().strftime("%Y-%m-%d")
 

examples/spanish/mcp_server.py

@@ -1,7 +1,7 @@
 """
-Example MCP server for expense tracking.
+Servidor MCP de ejemplo para seguimiento de gastos.
 
-Run this server first and then use agent_mcp_local.py to connect:
+Ejecuta este servidor primero y luego usa agent_mcp_local.py para conectarte:
     python examples/spanish/mcp_server.py
     python examples/spanish/agent_mcp_local.py
 """
@@ -26,15 +26,15 @@
 
 
 class PaymentMethod(Enum):
-    """Accepted payment methods for expenses."""
+    """Métodos de pago aceptados para gastos."""
 
     AMEX = "amex"
     VISA = "visa"
     CASH = "cash"
 
 
 class Category(Enum):
-    """Expense categories for classification."""
+    """Categorías de gastos para clasificación."""
 
     FOOD = "comida"
     TRANSPORT = "transporte"
@@ -52,7 +52,7 @@ async def add_expense(
     description: Annotated[str, "Human-readable expense description"],
     payment_method: Annotated[PaymentMethod, "Payment method used"],
 ) -> str:
-    """Add a new expense to the expenses.csv file."""
+    """Agrega un nuevo gasto al archivo expenses.csv."""
     if amount <= 0:
         return "Error: El monto debe ser positivo"
 
@@ -77,7 +77,7 @@ async def add_expense(
 
 @mcp.resource("resource://expenses")
 async def get_expenses_data() -> str:
-    """Get expense data from the CSV file."""
+    """Obtiene los datos de gastos desde el archivo CSV."""
     logger.info("Datos de gastos consultados")
 
     try:

examples/spanish/openai_tool_calling.py

@@ -28,7 +28,7 @@
 
 
 def lookup_weather(city_name: str | None = None, zip_code: str | None = None) -> dict:
-    """Look up weather for a given city name or zip code."""
+    """Consulta el clima para un nombre de ciudad o código postal dado."""
     return {
         "city_name": city_name,
         "zip_code": zip_code,

examples/spanish/workflow_basic.py

@@ -33,7 +33,7 @@
 
 # Define la salida estructurada para los resultados de revisión
 class ReviewResult(BaseModel):
-    """Review evaluation with scores and feedback."""
+    """Evaluación de revisión con puntajes y retroalimentación."""
 
     score: int  # Puntaje general de calidad (0-100)
     feedback: str  # Retroalimentación concisa y accionable
@@ -45,7 +45,7 @@ class ReviewResult(BaseModel):
 
 # Función de condición: envía al editor si puntaje < 80
 def needs_editing(message: Any) -> bool:
-    """Check if the content needs editing based on the review score."""
+    """Verifica si el contenido necesita edición según el puntaje de revisión."""
     if not isinstance(message, AgentExecutorResponse):
         return False
     try:
@@ -57,7 +57,7 @@ def needs_editing(message: Any) -> bool:
 
 # Función de condición: el contenido está aprobado (puntaje >= 80)
 def is_approved(message: Any) -> bool:
-    """Check if the content is approved (high quality)."""
+    """Verifica si el contenido está aprobado (alta calidad)."""
     if not isinstance(message, AgentExecutorResponse):
         return True
     try: