From 355fe4092fd64520f51cff10a1d301be94f75b46 Mon Sep 17 00:00:00 2001 From: dfcarvajal Date: Fri, 26 Dec 2025 11:02:26 +0100 Subject: [PATCH] LANG: set messages in spanish --- src/app.py | 270 ++++++++++++++++++++++++++--------------------------- 1 file changed, 135 insertions(+), 135 deletions(-) diff --git a/src/app.py b/src/app.py index f7ece6e..2a3523c 100644 --- a/src/app.py +++ b/src/app.py @@ -80,16 +80,16 @@ def train(): # Validar que el tipo de modelo existe if model_type and not model_config.model_exists(model_type): return jsonify({ - "error": f"Model type '{model_type}' not found", - "available_models": model_config.get_all_model_types() + "error": f"Tipo de modelo '{model_type}' no encontrado", + "modelos_disponibles": model_config.get_all_model_types() }), 400 threading.Thread(target=model_trainer.background_train, args=(model_type,)).start() return jsonify({ - "status": "training started", - "model_type": model_type or "all", - "timestamp": datetime.now().isoformat() + "estado": "entrenamiento iniciado", + "tipo_modelo": model_type or "todos", + "marca_tiempo": datetime.now().isoformat() }) @app.route("/predict", methods=["GET"]) @@ -115,14 +115,14 @@ def register_new_model(): print(f" Configuración: {new_config}") return jsonify({ - "status": "model type registered", - "model_type": data["type"], - "config": new_config + "estado": "tipo de modelo registrado", + "tipo_modelo": data["type"], + "configuracion": new_config }) except ValueError as e: return jsonify({"error": str(e)}), 400 except Exception as e: - return jsonify({"error": f"Registration failed: {str(e)}"}), 500 + return jsonify({"error": f"Registro fallido: {str(e)}"}), 500 @app.route("/models", methods=["GET"]) def list_models(): @@ -134,25 +134,25 @@ def list_models(): model_config_info = model_config.get_model_config(model_type) model_info = { - "type": model_type, - "description": model_config_info.get("description", ""), - "loaded": model is not None, - "required_params": model_config_info.get("required_params", []), - "module": model_config_info.get("module"), - "train_function": model_config_info.get("train_function"), - "output_type": model_config_info.get("output_type", "unknown") + "tipo": model_type, + "descripcion": model_config_info.get("description", ""), + "cargado": model is not None, + "parametros_requeridos": model_config_info.get("required_params", []), + "modulo": model_config_info.get("module"), + "funcion_entrenamiento": model_config_info.get("train_function"), + "tipo_salida": model_config_info.get("output_type", "desconocido") } # Añadir información del archivo si existe from model_registry import load_meta meta = load_meta() if model_type in meta.get("current", {}): - model_info["file"] = meta["current"][model_type] + model_info["archivo"] = meta["current"][model_type] models_info.append(model_info) return jsonify({ - "available_models": models_info, + "modelos_disponibles": models_info, "total": len(models_info) }) @@ -185,11 +185,11 @@ def recommend_gruas(): # Validar parámetros if not (0 <= dow <= 6): - return jsonify({"error": "dow must be between 0 and 6"}), 400 + return jsonify({"error": "dow debe estar entre 0 y 6"}), 400 if not (0 <= hour <= 23): - return jsonify({"error": "hour must be between 0 and 23"}), 400 + return jsonify({"error": "hour debe estar entre 0 y 23"}), 400 if k < 1: - return jsonify({"error": "k must be at least 1"}), 400 + return jsonify({"error": "k debe ser al menos 1"}), 400 # Obtener modelos demand_model = model_manager.get_model("demand") @@ -197,7 +197,7 @@ def recommend_gruas(): if demand_model is None or nulo_model is None: return jsonify({ - "error": "Required models not loaded. Please train demand and nulo models first." + "error": "Modelos requeridos no cargados. Por favor, entrene primero los modelos de demanda y nulo." }), 500 if DEBUG_MODE: @@ -208,7 +208,7 @@ def recommend_gruas(): if df.empty: return jsonify({ - "error": "No prediction data available for the specified parameters" + "error": "No hay datos de predicción disponibles para los parámetros especificados" }), 404 if DEBUG_MODE: @@ -231,24 +231,24 @@ def recommend_gruas(): return jsonify(result), 500 response = { - "week": week, - "dow": dow, - "hour": hour, - "optimization": { - "optimal_k": result['optimal_k'], - "coverage_percentage": result['coverage_percentage'], - "risk_coverage_percentage": result['risk_coverage_percentage'], - "target_coverage": target_coverage + "semana": week, + "dia_semana": dow, + "hora": hour, + "optimizacion": { + "k_optimo": result['optimal_k'], + "porcentaje_cobertura": result['coverage_percentage'], + "porcentaje_cobertura_riesgo": result['risk_coverage_percentage'], + "cobertura_objetivo": target_coverage }, - "recommended_h3": result['selected_cells'], - "statistics": result.get('placement', {}).get('statistics', []), - "coverage": result.get('placement', {}).get('coverage', {}) + "h3_recomendados": result['selected_cells'], + "estadisticas": result.get('placement', {}).get('statistics', []), + "cobertura": result.get('placement', {}).get('coverage', {}) } # Incluir todos los resultados si está en modo debug if DEBUG_MODE: response['debug'] = { - 'all_results': result.get('all_results', []) + 'todos_resultados': result.get('all_results', []) } else: @@ -258,30 +258,30 @@ def recommend_gruas(): result = place_gruas(df, k=k) response = { - "week": week, - "dow": dow, - "hour": hour, - "parameters": { + "semana": week, + "dia_semana": dow, + "hora": hour, + "parametros": { "k": k, - "optimization": optimize + "optimizacion": optimize }, - "recommended_h3": result['selected'], - "statistics": result.get('statistics', []), - "coverage": result.get('coverage', {}) + "h3_recomendados": result['selected'], + "estadisticas": result.get('statistics', []), + "cobertura": result.get('coverage', {}) } include_cell_data = request.args.get("include_cell_data", "false").lower() == "true" if include_cell_data: - response['prediction_data'] = df.to_dict('records') + response['datos_prediccion'] = df.to_dict('records') return jsonify(response) except KeyError as e: - return jsonify({"error": f"Missing required parameter: {str(e)}"}), 400 + return jsonify({"error": f"Falta parámetro requerido: {str(e)}"}), 400 except ValueError as e: - return jsonify({"error": f"Invalid parameter value: {str(e)}"}), 400 + return jsonify({"error": f"Valor de parámetro inválido: {str(e)}"}), 400 except Exception as e: if DEBUG_MODE: import traceback @@ -289,7 +289,7 @@ def recommend_gruas(): traceback.print_exc() return jsonify({ - "error": f"Internal server error: {str(e)}" + "error": f"Error interno del servidor: {str(e)}" }), 500 @app.route("/coverage/radius", methods=["GET"]) @@ -317,17 +317,17 @@ def get_coverage_radius(): level = "alta" return jsonify({ - "demand": demand, - "demand_level": level, - "coverage_radius": radius, - "coverage_weight": weight, - "explanation": f"Para demanda {level} ({demand:.2f}), el radio de cobertura es {radius}" + "demanda": demand, + "nivel_demanda": level, + "radio_cobertura": radius, + "peso_cobertura": weight, + "explicacion": f"Para demanda {level} ({demand:.2f}), el radio de cobertura es {radius}" }) except (KeyError, ValueError) as e: - return jsonify({"error": f"Invalid parameter: {str(e)}"}), 400 + return jsonify({"error": f"Parámetro inválido: {str(e)}"}), 400 except Exception as e: - return jsonify({"error": f"Internal error: {str(e)}"}), 500 + return jsonify({"error": f"Error interno: {str(e)}"}), 500 @app.route("/coverage/cells", methods=["GET"]) def get_coverage_cells(): @@ -352,7 +352,7 @@ def get_coverage_cells(): radius = coverage_radius(demand) else: return jsonify({ - "error": "Either radius or demand parameter is required" + "error": "Se requiere el parámetro radius o demand" }), 400 # Calcular celdas cubiertas @@ -360,16 +360,16 @@ def get_coverage_cells(): return jsonify({ "h3": h3_cell, - "radius": radius, - "cells_covered": len(cells), - "covered_cells": list(cells)[:100], # Limitar para no sobrecargar respuesta - "truncated": len(cells) > 100 + "radio": radius, + "celdas_cubiertas": len(cells), + "celdas_cubiertas_lista": list(cells)[:100], # Limitar para no sobrecargar respuesta + "truncado": len(cells) > 100 }) except (KeyError, ValueError) as e: - return jsonify({"error": f"Invalid parameter: {str(e)}"}), 400 + return jsonify({"error": f"Parámetro inválido: {str(e)}"}), 400 except Exception as e: - return jsonify({"error": f"Internal error: {str(e)}"}), 500 + return jsonify({"error": f"Error interno: {str(e)}"}), 500 @app.route("/risk/calculate", methods=["GET"]) def calculate_risk_endpoint(): @@ -387,21 +387,21 @@ def calculate_risk_endpoint(): from algorithms.placement import calculate_risk if not 0 <= nulo_prob <= 1: - return jsonify({"error": "nulo_prob must be between 0 and 1"}), 400 + return jsonify({"error": "nulo_prob debe estar entre 0 y 1"}), 400 risk = calculate_risk(demand, nulo_prob) return jsonify({ - "demand": demand, - "nulo_probability": nulo_prob, - "risk": risk, - "explanation": f"Riesgo = demanda × probabilidad_nulo = {demand} × {nulo_prob} = {risk:.4f}" + "demanda": demand, + "probabilidad_nulo": nulo_prob, + "riesgo": risk, + "explicacion": f"Riesgo = demanda × probabilidad_nulo = {demand} × {nulo_prob} = {risk:.4f}" }) except (KeyError, ValueError) as e: - return jsonify({"error": f"Invalid parameter: {str(e)}"}), 400 + return jsonify({"error": f"Parámetro inválido: {str(e)}"}), 400 except Exception as e: - return jsonify({"error": f"Internal error: {str(e)}"}), 500 + return jsonify({"error": f"Error interno: {str(e)}"}), 500 @app.route("/health", methods=["GET"]) def health(): @@ -410,18 +410,18 @@ def health(): all_models = model_config.get_all_model_types() response = { - "status": "healthy" if all(loaded_models.values()) else "partial", - "models_loaded": loaded_models, - "total_configured": len(all_models), - "loaded_count": sum(1 for v in loaded_models.values() if v), - "debug_mode": DEBUG_MODE + "estado": "saludable" if all(loaded_models.values()) else "parcial", + "modelos_cargados": loaded_models, + "total_configurados": len(all_models), + "cantidad_cargados": sum(1 for v in loaded_models.values() if v), + "modo_depuracion": DEBUG_MODE } if DEBUG_MODE: - response["environment"] = { + response["entorno"] = { "host": HOST, - "port": PORT, - "python_version": os.getenv("PYTHON_VERSION", "unknown") + "puerto": PORT, + "version_python": os.getenv("PYTHON_VERSION", "desconocido") } return jsonify(response) @@ -430,17 +430,17 @@ def health(): def debug_info(): """Endpoint de información de debug (solo disponible en modo debug)""" if not DEBUG_MODE: - return jsonify({"error": "Debug mode is disabled"}), 403 + return jsonify({"error": "El modo debug está desactivado"}), 403 import sys import importlib # Información del sistema system_info = { - "python_version": sys.version, - "platform": sys.platform, - "working_directory": os.getcwd(), - "environment_variables": { + "version_python": sys.version, + "plataforma": sys.platform, + "directorio_trabajo": os.getcwd(), + "variables_entorno": { k: v for k, v in os.environ.items() if k.startswith(('FLASK_', 'DB_', 'PYTHON')) } @@ -455,8 +455,8 @@ def debug_info(): if module_name in sys.modules: module = sys.modules[module_name] loaded_modules[module_name] = { - "file": getattr(module, '__file__', 'unknown'), - "functions": [f for f in dir(module) if not f.startswith('_')] + "archivo": getattr(module, '__file__', 'desconocido'), + "funciones": [f for f in dir(module) if not f.startswith('_')] } # Información de memoria de modelos @@ -465,18 +465,18 @@ def debug_info(): if model is not None: try: models_memory[model_type] = { - "type": type(model).__name__, - "attributes": [attr for attr in dir(model) if not attr.startswith('_')] + "tipo": type(model).__name__, + "atributos": [attr for attr in dir(model) if not attr.startswith('_')] } except: - models_memory[model_type] = {"type": "unknown"} + models_memory[model_type] = {"tipo": "desconocido"} return jsonify({ - "system": system_info, - "loaded_modules": loaded_modules, - "models_in_memory": models_memory, - "debug_mode": DEBUG_MODE, - "timestamp": datetime.now().isoformat() + "sistema": system_info, + "modulos_cargados": loaded_modules, + "modelos_en_memoria": models_memory, + "modo_depuracion": DEBUG_MODE, + "marca_tiempo": datetime.now().isoformat() }) @app.route("/", methods=["GET"]) @@ -484,78 +484,78 @@ def index(): """Página principal con documentación""" endpoints = [ { - "path": "/predict", - "method": "GET", - "description": "Realizar predicción", - "parameters": "model_type (required), otros según modelo" + "ruta": "/predict", + "metodo": "GET", + "descripcion": "Realizar predicción", + "parametros": "model_type (requerido), otros según modelo" }, { - "path": "/demand", - "method": "GET", - "description": "Obtener predicciones masivas", - "parameters": "model_type (required), limit (opcional)" + "ruta": "/demand", + "metodo": "GET", + "descripcion": "Obtener predicciones masivas", + "parametros": "model_type (requerido), limit (opcional)" }, { - "path": "/train", - "method": "POST", - "description": "Entrenar modelos", - "parameters": "model_type (opcional)" + "ruta": "/train", + "metodo": "POST", + "descripcion": "Entrenar modelos", + "parametros": "model_type (opcional)" }, { - "path": "/recommend", - "method": "GET", - "description": "Recomendar ubicaciones para grúas", - "parameters": "week, dow, hour (requeridos), k, optimize, min_gruas, max_gruas, target_coverage (opcionales)" + "ruta": "/recommend", + "metodo": "GET", + "descripcion": "Recomendar ubicaciones para grúas", + "parametros": "week, dow, hour (requeridos), k, optimize, min_gruas, max_gruas, target_coverage (opcionales)" }, { - "path": "/coverage/radius", - "method": "GET", - "description": "Calcular radio de cobertura según demanda", - "parameters": "demand (requerido)" + "ruta": "/coverage/radius", + "metodo": "GET", + "descripcion": "Calcular radio de cobertura según demanda", + "parametros": "demand (requerido)" }, { - "path": "/coverage/cells", - "method": "GET", - "description": "Obtener celdas cubiertas por una celda H3", - "parameters": "h3 (requerido), radius o demand (opcional)" + "ruta": "/coverage/cells", + "metodo": "GET", + "descripcion": "Obtener celdas cubiertas por una celda H3", + "parametros": "h3 (requerido), radius o demand (opcional)" }, { - "path": "/risk/calculate", - "method": "GET", - "description": "Calcular riesgo (demanda × probabilidad nulo)", - "parameters": "demand, nulo_prob (requeridos)" + "ruta": "/risk/calculate", + "metodo": "GET", + "descripcion": "Calcular riesgo (demanda × probabilidad nulo)", + "parametros": "demand, nulo_prob (requeridos)" }, { - "path": "/models", - "method": "GET", - "description": "Listar modelos disponibles" + "ruta": "/models", + "metodo": "GET", + "descripcion": "Listar modelos disponibles" }, { - "path": "/models/register", - "method": "POST", - "description": "Registrar nuevo tipo de modelo" + "ruta": "/models/register", + "metodo": "POST", + "descripcion": "Registrar nuevo tipo de modelo" }, { - "path": "/health", - "method": "GET", - "description": "Estado del sistema" + "ruta": "/health", + "metodo": "GET", + "descripcion": "Estado del sistema" } ] if DEBUG_MODE: endpoints.append({ - "path": "/debug", - "method": "GET", - "description": "Información de debug", - "note": "Solo disponible en modo debug" + "ruta": "/debug", + "metodo": "GET", + "descripcion": "Información de debug", + "nota": "Solo disponible en modo debug" }) return jsonify({ - "service": "Model Prediction API", + "servicio": "API de Predicción de Modelos", "version": "1.0.0", - "debug_mode": DEBUG_MODE, + "modo_depuracion": DEBUG_MODE, "endpoints": endpoints, - "available_models": model_config.get_all_model_types() + "modelos_disponibles": model_config.get_all_model_types() }) if __name__ == "__main__":