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
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__":