""" Script de ejemplo para probar el nuevo sistema de proxy interno Este script se ejecutará como una aplicación Flask interna """ from flask import Flask, render_template_string, request, jsonify, redirect, url_for import os import sys from datetime import datetime import pandas as pd import matplotlib.pyplot as plt import io import base64 # Variables disponibles del wrapper automático: # - WORKSPACE_PATH: directorio de trabajo del script # - PARAMETERS: parámetros pasados al script # - ENVIRONMENT: variables de entorno # - PROJECT_WORKSPACE: alias para WORKSPACE_PATH print(f"Script iniciado en workspace: {WORKSPACE_PATH}") print(f"Parámetros recibidos: {PARAMETERS}") print(f"Variables de entorno: {ENVIRONMENT}") # Configurar aplicación Flask del usuario app.config.update({ 'DEBUG': False, 'TEMPLATES_AUTO_RELOAD': True }) # === RUTAS DEL SCRIPT DEL USUARIO === @app.route('/') def index(): """Página principal del script""" html_template = """ Script de Ejemplo - {{ script_name }}

{{ script_name }}

Ejemplo de script Flask ejecutándose a través del proxy interno

Información del Script

Workspace:
{{ workspace }}

Usuario: {{ user_info.get('username', 'N/A') }}

Proyecto: {{ project_info.get('name', 'N/A') }}

Iniciado: {{ start_time }}

Ejecutándose
Parámetros
{% if parameters %} {% for key, value in parameters.items() %}

{{ key }}: {{ value }}

{% endfor %} {% else %}

No hay parámetros

{% endif %}
Herramientas de Datos
Generar Datos
Crear Gráfico
Estado API
Explorar Archivos
Área de Resultados

Los resultados aparecerán aquí...

""" return render_template_string(html_template, script_name=ENVIRONMENT.get('SCRIPT_GROUP_NAME', 'Script de Ejemplo'), workspace=WORKSPACE_PATH, user_info={'username': ENVIRONMENT.get('USER_ID', 'demo')}, project_info={'name': ENVIRONMENT.get('PROJECT_NAME', 'Proyecto Demo')}, start_time=datetime.now().strftime('%Y-%m-%d %H:%M:%S'), parameters=PARAMETERS ) @app.route('/generate-data') def generate_data(): """Genera datos de ejemplo y los guarda en CSV""" import numpy as np # Generar datos aleatorios np.random.seed(42) dates = pd.date_range('2024-01-01', periods=100, freq='D') values = np.random.randn(100).cumsum() + 100 df = pd.DataFrame({ 'fecha': dates, 'valor': values, 'categoria': np.random.choice(['A', 'B', 'C'], 100) }) # Guardar en workspace csv_path = os.path.join(WORKSPACE_PATH, 'data', 'datos_generados.csv') df.to_csv(csv_path, index=False) html_result = f"""

Datos Generados Exitosamente

Se generaron {len(df)} registros y se guardaron en:

{csv_path}

Vista previa:
{df.head(10).to_html(classes='table table-striped table-sm', index=False)}
Volver
""" return html_result @app.route('/create-chart') def create_chart(): """Crea un gráfico con los datos generados""" try: # Leer datos si existen csv_path = os.path.join(WORKSPACE_PATH, 'data', 'datos_generados.csv') if not os.path.exists(csv_path): return """

No hay datos

Primero genera algunos datos usando el botón "Generar Datos"

Volver
""".format(url_for('index')) df = pd.read_csv(csv_path) df['fecha'] = pd.to_datetime(df['fecha']) # Crear gráfico plt.figure(figsize=(10, 6)) plt.plot(df['fecha'], df['valor'], marker='o', linewidth=2) plt.title('Evolución de Valores en el Tiempo', fontsize=16) plt.xlabel('Fecha') plt.ylabel('Valor') plt.grid(True, alpha=0.3) plt.xticks(rotation=45) plt.tight_layout() # Convertir a base64 para mostrar en HTML img_buffer = io.BytesIO() plt.savefig(img_buffer, format='png', dpi=150, bbox_inches='tight') img_buffer.seek(0) img_base64 = base64.b64encode(img_buffer.getvalue()).decode() plt.close() # Estadísticas básicas stats = df['valor'].describe() html_result = f"""

Gráfico Generado

Estadísticas:
Media:{stats['mean']:.2f}
Mediana:{stats['50%']:.2f}
Desv. Estándar:{stats['std']:.2f}
Mínimo:{stats['min']:.2f}
Máximo:{stats['max']:.2f}
Rango:{stats['max'] - stats['min']:.2f}
Volver
""" return html_result except Exception as e: return f"""

Error

Error creando el gráfico: {str(e)}

Volver
""" @app.route('/api/status') def api_status(): """Endpoint API que devuelve estado en JSON""" status_data = { 'status': 'running', 'timestamp': datetime.now().isoformat(), 'workspace': WORKSPACE_PATH, 'parameters': PARAMETERS, 'environment': ENVIRONMENT, 'pid': os.getpid(), 'python_version': sys.version, 'files_in_workspace': os.listdir(WORKSPACE_PATH) } return jsonify(status_data) @app.route('/files') def file_browser(): """Explorador simple de archivos del workspace""" try: files = [] for root, dirs, filenames in os.walk(WORKSPACE_PATH): for filename in filenames: full_path = os.path.join(root, filename) rel_path = os.path.relpath(full_path, WORKSPACE_PATH) stat = os.stat(full_path) files.append({ 'path': rel_path, 'size': stat.st_size, 'modified': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S') }) html_template = """

Explorador de Archivos - Workspace

{{ workspace }}
{% if files %}
{% for file in files %} {% endfor %}
Archivo Tamaño Modificado
{{ file.path }} {{ file.size }} bytes {{ file.modified }}
{% else %}

No hay archivos en el workspace

{% endif %} Volver
""" return render_template_string(html_template, files=files, workspace=WORKSPACE_PATH) except Exception as e: return f"""

Error

Error explorando archivos: {str(e)}

Volver
""" # Endpoint especial para testing @app.route('/test-proxy') def test_proxy(): """Endpoint para probar que el proxy funciona correctamente""" return jsonify({ 'message': 'Proxy funcionando correctamente!', 'timestamp': datetime.now().isoformat(), 'request_info': { 'method': request.method, 'path': request.path, 'args': dict(request.args), 'headers': dict(request.headers) } }) print("Script de ejemplo cargado y listo para recibir peticiones") print(f"Rutas disponibles:") print(" / - Página principal") print(" /generate-data - Generar datos de ejemplo") print(" /create-chart - Crear gráfico") print(" /api/status - Estado del script (JSON)") print(" /files - Explorador de archivos") print(" /test-proxy - Test del proxy") print(" /health - Health check (automático)")