TFM/microservicios_python
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LANG: set messages in spanish

Browse Source
This commit is contained in:
dfcarvajal
2025-12-26 11:02:26 +01:00
parent af464ebfb7
commit 355fe4092f
1 changed files with 135 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
src/app.py
View File

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