Update app.py

app.py

@@ -1,302 +1,120 @@
-# app.py
-
-import asyncio
+import os
+import requests
+from flask import Flask, render_template, request, flash, redirect, url_for
 from bs4 import BeautifulSoup
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.chrome.service import Service as ChromeService
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.common.exceptions import NoSuchElementException, TimeoutException
-from urllib.parse import urljoin, urlparse
 import pandas as pd
-import re
-import random
 import time
-from datetime import datetime
-import gradio as gr
-import os
-import traceback
 
-# --- Funciones Utilitarias ---
-def clean_text(text):
-    if not isinstance(text, str): return ""
-    text = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', text)
-    return re.sub(r'\s+', ' ', text).strip()
+# --- Inicialización de la Aplicación Flask ---
+app = Flask(__name__)
+# Se necesita una clave secreta para mostrar mensajes (flashing)
+app.secret_key = 'supersecretkey' 
+
+# --- Lógica de Web Scraping ---
+def scrape_lobby_data():
+    """
+    Función que realiza el web scraping en el sitio de Ley de Lobby,
+    extrae los datos de audiencias y los guarda en archivos TXT y CSV.
+    """
+    # URL del sitio a scrapear para el año 2025
+    url = "https://www.leylobby.gob.cl/instituciones/AO001/audiencias/2025"
+
+    # --- Consideración Ética ---
+    # Es una buena práctica identificarse. Algunos sitios web pueden bloquear
+    # solicitudes sin un User-Agent reconocible.
+    headers = {
+        'User-Agent': 'EthicalScraper/1.0 (contacto@ejemplo.com) - Script para proyecto educativo'
+    }
 
-def extract_inst_anio_from_url(url):
-    parsed_url = urlparse(url)
-    path_parts = [part for part in parsed_url.path.split('/') if part]
-    inst_codigo, anio = "desconocida", "sin_año"
     try:
-        inst_index = path_parts.index('instituciones') + 1
-        if inst_index < len(path_parts): inst_codigo = path_parts[inst_index]
-        audiencias_index = path_parts.index('audiencias') + 1
-        if audiencias_index < len(path_parts) and path_parts[audiencias_index].isdigit():
-             potential_anio = path_parts[audiencias_index]
-             if 2000 <= int(potential_anio) <= datetime.now().year + 5: anio = potential_anio
-    except (ValueError, IndexError): pass
-    return inst_codigo, anio
-
-# --- Clase de Scraper Robusto con Selenium ---
-class SeleniumLobbyScraper:
-    def __init__(self, initial_audiencias_url):
-        if not initial_audiencias_url or not (initial_audiencias_url.startswith('http://') or initial_audiencias_url.startswith('https://')):
-            raise ValueError("La URL inicial debe ser una URL HTTP o HTTPS válida.")
-            
-        self.initial_audiencias_url = initial_audiencias_url
-        parsed = urlparse(initial_audiencias_url)
-        self.base_url = f"{parsed.scheme}://{parsed.netloc}"
-        self.institucion_codigo, self.anio = extract_inst_anio_from_url(initial_audiencias_url)
-        self.all_audiences_data = []
-        self.driver = None
-
-    def setup_driver(self):
-        print("Configurando el navegador virtual (Chrome)...")
-        options = webdriver.ChromeOptions()
-        # Argumentos esenciales para entornos como Hugging Face Spaces
-        options.add_argument("--headless=new") # Nuevo método para modo headless
-        options.add_argument("--no-sandbox")
-        options.add_argument("--disable-dev-shm-usage")
-        options.add_argument("--disable-gpu")
-        options.add_argument("--disable-extensions") # Deshabilitar extensiones
-        options.add_argument("--window-size=1920,1080")
-        options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+        # Realizar la solicitud GET para obtener el contenido de la página
+        print(f"Obteniendo datos desde: {url}")
+        response = requests.get(url, headers=headers, timeout=15)
+        # Genera un error si la solicitud no fue exitosa (ej. error 404, 500)
+        response.raise_for_status() 
+
+        # --- Parseo del HTML con BeautifulSoup ---
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Encontrar la tabla que contiene los datos de las audiencias
+        # Se debe inspeccionar el HTML del sitio para encontrar los selectores correctos.
+        table = soup.find('table', class_='table-striped')
         
-        # En HF Spaces, especificar la ruta del binario de Chrome instalado vía packages.txt
-        if os.path.exists("/usr/bin/google-chrome"):
-            print("Usando el binario de Chrome de /usr/bin/google-chrome")
-            options.binary_location = "/usr/bin/google-chrome"
-        
-        # Crear instancia de Selenium. Selenium Manager se encargará del driver automáticamente.
-        try:
-            print("Iniciando Selenium. Selenium Manager se encargará de encontrar/descargar el driver...")
-            self.driver = webdriver.Chrome(options=options)
-            print("Navegador virtual configurado exitosamente.")
-        except Exception as e:
-            print("Error FATAL al configurar Selenium. Verifica que el Dockerfile haya instalado Chrome correctamente.")
-            traceback.print_exc()
-            raise e
+        if not table:
+            print("No se encontró la tabla de datos. El sitio puede haber cambiado su estructura.")
+            return False, "No se pudo encontrar la tabla de datos en la página."
 
-    def shutdown_driver(self):
-        if self.driver:
-            self.driver.quit()
-            print("Navegador virtual cerrado.")
-            
-    async def get_audience_detail_urls(self):
-        print("Navegando a la página inicial y esperando contenido dinámico...")
-        self.driver.get(self.initial_audiencias_url)
-        all_detail_urls = set()
-        page_num = 1
+        # --- Extracción de Datos ---
+        # Extraer los encabezados de la tabla
+        headers_list = [th.get_text(strip=True) for th in table.find('thead').find_all('th')]
         
-        while True:
-            await asyncio.sleep(random.uniform(2, 4)) # Pequeña pausa para estabilidad
-            try:
-                # Espera a que la tabla o lista de audiencias sea visible
-                wait = WebDriverWait(self.driver, 20)
-                # Selectores genéricos para una tabla de datos. Si falla, es lo primero a ajustar.
-                wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "table.audiencias, table.table, .audiencias-list, #audiencias")))
-                print(f"Contenido dinámico detectado en la página {page_num}.")
-                
-                # Extraer todos los enlaces "Ver Detalle" de la página actual
-                # Selector genérico que busca cualquier enlace 'a' que contenga '/audiencias/detalle/'
-                detail_links = self.driver.find_elements(By.CSS_SELECTOR, 'a[href*="/audiencias/detalle/"]')
-                if not detail_links:
-                    print(f"ADVERTENCIA: No se encontraron enlaces de detalle en la página {page_num}.")
-
-                for link in detail_links:
-                    href = link.get_attribute('href')
-                    if href: all_detail_urls.add(href)
-                print(f"Recolectados {len(detail_links)} enlaces en la página {page_num}. Total únicos: {len(all_detail_urls)}")
-                
-                # Intentar ir a la siguiente página
-                # Selector genérico para un botón de paginación "Siguiente".
-                next_button = self.driver.find_element(By.CSS_SELECTOR, "li.pagination-next:not(.disabled) a, a.page-link[aria-label='Next']")
-                print("Botón 'Siguiente' encontrado, haciendo clic...")
-                self.driver.execute_script("arguments[0].click();", next_button) # Click con JS para evitar problemas de "interactability"
-                page_num += 1
-
-            except TimeoutException:
-                print("Timeout esperando el contenido de la tabla en la página. Asumiendo que no hay más audiencias.")
-                break # Sale si el contenido principal nunca aparece
-            except NoSuchElementException:
-                print("No se encontró el botón 'Siguiente' o ya está deshabilitado. Finalizando paginación.")
-                break # Sale del bucle si no hay botón "Siguiente"
+        # Extraer las filas de datos de la tabla
+        data_rows = []
+        for row in table.find('tbody').find_all('tr'):
+            columns = [td.get_text(strip=True) for td in row.find_all('td')]
+            data_rows.append(columns)
         
-        return list(all_detail_urls)
-
-    async def extract_audience_detail(self, detail_url):
-        try:
-            self.driver.get(detail_url)
-            wait = WebDriverWait(self.driver, 20)
-            # Esperar a que un elemento clave de la página de detalle sea visible
-            # Selector genérico, si falla, es lo tercero a ajustar.
-            wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "div.materia, div.info-audiencia, #detalle_audiencia")))
-            
-            soup = BeautifulSoup(self.driver.page_source, 'html.parser')
-            
-            data = {"Link Audiencia": detail_url, "Identificador Audiencia": detail_url.split('/')[-1]}
-            
-            # --- Extracción de datos con selectores genéricos y manejo de errores ---
-            # Intenta con varios selectores comunes por cada campo. Si ninguno funciona, deja el campo vacío.
-            
-            # Fecha y Hora
-            fecha_hora_elem = soup.select_one(".fecha-audiencia, .audiencia-fecha, #fecha_audiencia")
-            fecha_hora_text = clean_text(fecha_hora_elem.get_text()) if fecha_hora_elem else ""
-            data['Fecha'], data['Hora'] = "", ""
-            if fecha_hora_text:
-                try: dt_obj = datetime.strptime(fecha_hora_text.strip(), '%d/%m/%Y %H:%M'); data['Fecha'], data['Hora'] = dt_obj.strftime('%Y-%m-%d'), dt_obj.strftime('%H:%M')
-                except ValueError: parts = fecha_hora_text.strip().split(maxsplit=1); data['Fecha'], data['Hora'] = parts[0] if parts else fecha_hora_text, parts[1] if len(parts)>1 else ""
-            
-            # Funcionario
-            func_nombre = soup.select_one(".funcionario-nombre, .nombre-funcionario, #funcionario_nombre")
-            func_cargo = soup.select_one(".funcionario-cargo, .cargo-funcionario, #funcionario_cargo")
-            data['Funcionario (nombre, cargo, código)'] = f"{clean_text(func_nombre.get_text()) if func_nombre else 'N/A'} ({clean_text(func_cargo.get_text()) if func_cargo else 'N/A'}, N/A)"
-
-            # Materia y Detalle
-            data['Materia'] = clean_text(soup.select_one(".materia, .audiencia-materia, #materia_audiencia").get_text()) if soup.select_one(".materia, .audiencia-materia, #materia_audiencia") else ""
-            data['Detalle'] = clean_text(soup.select_one(".detalle, .audiencia-detalle, #detalle_audiencia").get_text()) if soup.select_one(".detalle, .audiencia-detalle, #detalle_audiencia") else ""
+        if not data_rows:
+            return False, "La tabla fue encontrada, pero no contenía datos de audiencias."
 
-            # Gestores y Representados
-            gestores_elems = soup.select(".ficha-gestor, .gestor-item, .info-gestor")
-            gestores_representados_list = []
-            if not gestores_elems: gestores_representados_list.append({'Gestor Nombre': '', 'Gestor Empresa': '', 'Representados': ''})
-            else:
-                for gestor_elem in gestores_elems:
-                    nombre = clean_text(gestor_elem.select_one(".nombre-gestor, .gestor-nombre").get_text()) if gestor_elem.select_one(".nombre-gestor, .gestor-nombre") else ""
-                    empresa = clean_text(gestor_elem.select_one(".empresa-gestor, .gestor-empresa").get_text()) if gestor_elem.select_one(".empresa-gestor, .gestor-empresa") else ""
-                    representados_nombres = ", ".join([clean_text(rep.get_text()) for rep in gestor_elem.select(".lista-representados li, .representado-item")])
-                    gestores_representados_list.append({'Gestor Nombre': nombre, 'Gestor Empresa': empresa, 'Representados': representados_nombres})
-            
-            # Participantes
-            participantes_elems = soup.select(".lista-participantes li, .participante-item")
-            participantes_list = []
-            for part_elem in participantes_elems:
-                nombre = clean_text(part_elem.select_one(".nombre-participante, .nombre").get_text()) if part_elem.select_one(".nombre-participante, .nombre") else ""
-                rol = clean_text(part_elem.select_one(".rol-participante, .rol").get_text()) if part_elem.select_one(".rol-participante, .rol") else ""
-                if nombre or rol: participantes_list.append(f"{nombre} ({rol})")
-            data['Participantes (rol)'] = "; ".join(participantes_list)
-            
-            # Aplanar datos
-            flattened_rows = []
-            for gr in gestores_representados_list:
-                row = data.copy()
-                nombre_f, empresa_f = gr.get('Gestor Nombre','').strip(), gr.get('Gestor Empresa','').strip()
-                if nombre_f and empresa_f: row['Gestor de intereses (nombre, empresa)'] = f"{nombre_f} ({empresa_f})"
-                elif nombre_f: row['Gestor de intereses (nombre, empresa)'] = nombre_f
-                elif empresa_f: row['Gestor de intereses (nombre, empresa)'] = empresa_f
-                else: row['Gestor de intereses (nombre, empresa)'] = ""
-                row['Representados'] = gr.get('Representados','')
-                flattened_rows.append(row)
-            
-            return flattened_rows
-            
-        except Exception as e:
-            print(f"Error EXCEPCIONAL al procesar {detail_url}: {e}"); traceback.print_exc()
-            return [{"Link Audiencia": detail_url, "Identificador Audiencia": detail_url.split('/')[-1], "Fecha": "Error Parse", "Hora": "Error Parse", "Funcionario (nombre, cargo, código)": "Error Parse", "Gestor de intereses (nombre, empresa)": "Error Parse", "Representados": "Error Parse", "Materia": "Error Parse", "Detalle": "Error Parse", "Participantes (rol)": "Error Parse", "Temas detectados": "Error Parse"}]
-    
-    async def run(self):
-        try:
-            yield "Configurando navegador virtual...", "Procesando...", None, None
-            self.setup_driver()
-
-            yield "Recolectando URLs de detalle...", "Navegando y esperando JavaScript...", None, None
-            audiencia_detail_urls = await self.get_audience_detail_urls()
-
-            if not audiencia_detail_urls:
-                 summary_no_urls = "No se encontraron URLs de detalle para extraer.\n\n**Posibles causas:**\n1. No hay audiencias publicadas para la URL/fecha.\n2. Los selectores CSS genéricos no coinciden con la estructura del sitio.\n3. El sitio requiere una interacción más compleja que la actual.\n\nEl proceso ha finalizado."
-                 yield "Proceso finalizado: No se encontraron URLs.", summary_no_urls, None, None
-                 return
+        # --- Guardado de Archivos ---
+        # Crear un DataFrame de pandas con los datos extraídos
+        df = pd.DataFrame(data_rows, columns=headers_list)
 
-            yield f"Recolectadas {len(audiencia_detail_urls)} URLs. Extrayendo detalles...", "Procesando...", None, None
-            
-            # Usamos un bucle for secuencial para la extracción para mayor estabilidad con Selenium
-            all_results = []
-            for i, url in enumerate(audiencia_detail_urls):
-                print(f"Procesando detalle {i+1}/{len(audiencia_detail_urls)}: {url}")
-                yield f"Extrayendo detalle {i+1}/{len(audiencia_detail_urls)}...", f"URL: {url}", None, None
-                result_list = await self.extract_audience_detail(url)
-                all_results.append(result_list)
-            
-            self.all_audiences_data = [item for sublist in all_results for item in sublist]
-            
-            print(f"Extracción completa. Total de registros: {len(self.all_audiences_data)}")
-            
-            # Generate final summary and files
-            df = pd.DataFrame(self.all_audiences_data)
-            required_cols_final = ['Fecha', 'Hora', 'Identificador Audiencia', 'Link Audiencia', 'Funcionario (nombre, cargo, código)', 'Gestor de intereses (nombre, empresa)', 'Representados', 'Materia', 'Detalle', 'Participantes (rol)']
-            # FIX: Corrected syntax for creating columns if not exists
-            for col in required_cols_final:
-                if col not in df.columns:
-                    df[col] = None
-            df = df[required_cols_final]
-            
-            summary_analysis = "✅ ¡Extracción completada!\n\n"
-            df_success = df[~df['Fecha'].astype(str).str.startswith('Error')].copy()
-            summary_analysis += f"**Total de audiencias únicas procesadas exitosamente:** {df_success['Link Audiencia'].nunique()}\n"
-            summary_analysis += f"**Total de registros generados (incluyendo duplicados por gestor):** {len(df_success)}\n"
-            
-            if len(df) > len(df_success):
-                summary_analysis += f"**Audiencias con errores de extracción:** {len(df) - len(df_success)}\n"
+        # 1. Guardar en formato CSV
+        df.to_csv('audiencias_lobby.csv', index=False, encoding='utf-8-sig')
+        print("Datos guardados exitosamente en 'audiencias_lobby.csv'")
 
-            # Exportar archivos
-            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S'); output_dir = "output_data"; os.makedirs(output_dir, exist_ok=True)
-            csv_filename = os.path.join(output_dir, f"leylobby_audiencias_{self.institucion_codigo}_{self.anio}_{timestamp}.csv")
-            df.to_csv(csv_filename, index=False, encoding='utf-8-sig')
-            
-            yield "Proceso finalizado.", summary_analysis, csv_filename, None
-            
-        except Exception as e:
-            print(f"Error crítico en el scraper: {e}"); traceback.print_exc()
-            yield "Error crítico.", f"Ocurrió un error grave: {e}\n\n{traceback.format_exc()}", None, None
-        finally:
-            self.shutdown_driver()
+        # 2. Guardar en formato TXT (formato de texto plano separado por comas)
+        df.to_csv('audiencias_lobby.txt', index=False, sep='\t')
+        print("Datos guardados exitosamente en 'audiencias_lobby.txt'")
 
-
-# --- Interfaz Gradio ---
-def create_interface():
-    with gr.Blocks(title="🤖 Ley Lobby Scraper Robusto", theme=gr.themes.Soft(primary_hue="blue", secondary_hue="gray")) as demo:
-        gr.HTML("""<div style="text-align: center; background: linear-gradient(135deg, #1e3a8a 0%, #1e40af 100%); color: white; padding: 25px; border-radius: 15px; margin-bottom: 25px;">
-            <h1>🤖 Ley Lobby Scraper Robusto</h1>
-            <p>Extractor inteligente que usa un navegador virtual para sortear defensas comunes y ejecutar JavaScript.</p></div>""")
-        
-        with gr.Row():
-            url_input = gr.Textbox(label="🌐 URL de Audiencias", placeholder="https://www.leylobby.gob.cl/instituciones/AO001/audiencias/2025", info="Introduce la URL principal de audiencias.")
-            scrape_btn = gr.Button("🚀 Iniciar Extracción Inteligente", variant="primary", size="lg")
+        # --- Pausa Ética ---
+        # Si fueras a hacer más solicitudes, es bueno esperar un momento.
+        time.sleep(1)
         
-        with gr.Group():
-            status_output = gr.Textbox(label="📊 Estado del Proceso", lines=3, interactive=False, autoscroll=True)
-            summary_output = gr.Textbox(label="📋 Resumen Ejecutivo", lines=10, interactive=False, autoscroll=True)
-        
-        with gr.Row():
-            download_file_csv = gr.File(label="📥 Descargar Reporte CSV Completo", interactive=False)
-            download_file_txt = gr.File(label="📥 Descargar Resumen TXT", interactive=False)
-
-        async def run_task(initial_url):
-             if not initial_url or not (initial_url.startswith('http://') or initial_url.startswith('https://')):
-                  yield "Error: URL inválida.", "Por favor, introduce una URL válida.", None, None
-                  return
-             try:
-                 scraper = SeleniumLobbyScraper(initial_url)
-                 async for status, summary, csv_file, txt_file in scraper.run():
-                      yield status, summary, csv_file, txt_file
-             except Exception as e:
-                 yield "Error Crítico", f"Error: {e}\n{traceback.format_exc()}", None, None
-                 
-        scrape_btn.click(
-            fn=run_task,
-            inputs=[url_input],
-            outputs=[status_output, summary_output, download_file_csv, download_file_txt]
-        )
+        return True, f"¡Éxito! Se extrajeron {len(data_rows)} registros y se guardaron en 'audiencias_lobby.csv' y 'audiencias_lobby.txt'."
+
+    except requests.exceptions.RequestException as e:
+        # Capturar errores de red (ej. sin conexión, DNS no encontrado)
+        error_message = f"Error de red al intentar acceder a la URL: {e}"
+        print(error_message)
+        return False, error_message
+    except Exception as e:
+        # Capturar cualquier otro error inesperado
+        error_message = f"Ocurrió un error inesperado: {e}"
+        print(error_message)
+        return False, error_message
+
+# --- Rutas de la Aplicación Web ---
+
+@app.route('/')
+def index():
+    """
+    Renderiza la página principal (index.html).
+    """
+    return render_template('index.html')
+
+@app.route('/scrape', methods=['POST'])
+def run_scraper():
+    """
+    Esta ruta se activa cuando se hace clic en el botón del formulario.
+    Llama a la función de scraping y muestra un mensaje al usuario.
+    """
+    print("Iniciando proceso de scraping...")
+    success, message = scrape_lobby_data()
+    
+    # Muestra un mensaje de éxito o error en la página
+    if success:
+        flash(message, 'success')
+    else:
+        flash(message, 'error')
         
-        gr.Markdown("### ¿Cómo funciona?\nEste sistema utiliza un navegador web virtual (Selenium con Chrome) para cargar completamente las páginas, incluyendo contenido dinámico de JavaScript. Navega automáticamente a través de la paginación para encontrar todas las audiencias y luego extrae los detalles de cada una. Esto lo hace mucho más resistente a los sitios web modernos que los scrapers tradicionales.")
-
-    return demo
-
-# --- Bloque principal para ejecutar la aplicación Gradio ---
-if __name__ == "__main__":
-    # Necesitarás instalar las dependencias: pip install selenium webdriver-manager
-    print("Iniciando aplicación Gradio con scraper basado en Selenium...")
-    demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-    print("Aplicación Gradio lanzada.")
+    # Redirige al usuario de vuelta a la página principal
+    return redirect(url_for('index'))
+
+# --- Punto de Entrada Principal ---
+if __name__ == '__main__':
+    # Inicia el servidor de desarrollo de Flask
+    # El debug=True permite ver los errores en el navegador y recarga el servidor automáticamente
+    app.run(debug=True)