Update app.py

app.py

@@ -1,11 +1,15 @@
-# app.py - Scraper Ley Lobby 100% Adaptativo
-# Autor: Sistema Inteligente de Extracción
-# Fecha: 2025
-# Funciona con CUALQUIER institución y año sin modificaciones
+# app.py
 
 import asyncio
 import aiohttp
 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 webdriver_manager.chrome import ChromeDriverManager
 from urllib.parse import urljoin, urlparse
 import pandas as pd
 import re
@@ -16,971 +20,267 @@ import gradio as gr
 import os
 import traceback
 import ssl
-from typing import Dict, List, Optional, Tuple, Any, Union
-import json
-from dataclasses import dataclass, asdict
-import logging
-from concurrent.futures import ThreadPoolExecutor
-import requests
-from functools import wraps
 
-# Configuración de logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
+# --- 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()
 
-# ==================== MOTOR DE DETECCIÓN SEMÁNTICA ====================
-class SemanticDetector:
-    """Motor de detección semántica que encuentra elementos por significado, no por CSS"""
-    
-    def __init__(self):
-        self.semantic_patterns = {
-            'detail_link': [
-                {'text': r'ver\s+detalle', 'case_sensitive': False},
-                {'text': r'detalle', 'case_sensitive': False},
-                {'text': r'ver\s+más', 'case_sensitive': False},
-                {'href': r'/audiencias/\d+', 'case_sensitive': False},
-                {'href': r'detalle', 'case_sensitive': False}
-            ],
-            'next_page': [
-                {'text': r'siguiente', 'case_sensitive': False},
-                {'text': r'next', 'case_sensitive': False},
-                {'text': r'›', 'case_sensitive': True},
-                {'text': r'>', 'case_sensitive': True},
-                {'rel': r'next', 'case_sensitive': False}
-            ],
-            'date_fields': [
-                {'text': r'fecha', 'case_sensitive': False},
-                {'text': r'date', 'case_sensitive': False},
-                {'label': r'fecha', 'case_sensitive': False}
-            ],
-            'funcionario_fields': [
-                {'text': r'funcionario', 'case_sensitive': False},
-                {'text': r'nombre', 'case_sensitive': False},
-                {'text': r'cargo', 'case_sensitive': False}
-            ]
-        }
-        
-        self.date_patterns = [
-            r'\d{1,2}[/-]\d{1,2}[/-]\d{4}',
-            r'\d{4}[/-]\d{1,2}[/-]\d{1,2}',
-            r'\d{1,2}\s+de\s+\w+\s+de\s+\d{4}',
-            r'\d{1,2}\s+\w+\s+\d{4}'
-        ]
-        
-        self.time_patterns = [
-            r'\d{1,2}:\d{2}(?::\d{2})?',
-            r'\d{1,2}:\d{2}\s*(?:AM|PM|am|pm)?'
-        ]
-        
-        self.theme_keywords = {
-            'salud': ['medicamento', 'salud', 'hospital', 'médico', 'enfermedad', 'tratamiento', 'farmacia', 'droga', 'fármaco'],
-            'regulacion': ['regulación', 'normativa', 'ley', 'decreto', 'resolución', 'reglamento', 'circular', 'instructivo'],
-            'farmaceutica': ['farmacéutica', 'medicamento', 'droga', 'fármaco', 'laboratorio', 'bioequivalencia'],
-            'licitacion': ['licitación', 'concurso', 'contrato', 'compra', 'adquisición', 'proveedor'],
-            'tecnologia': ['tecnología', 'digital', 'sistema', 'plataforma', 'software', 'app', 'web'],
-            'emergencia': ['emergencia', 'urgencia', 'pandemia', 'crisis', 'desastre', 'contingencia'],
-            'alimentos': ['alimento', 'comida', 'nutrición', 'alimentario', 'consumo', 'dieta'],
-            'cosmeticos': ['cosmético', 'belleza', 'higiene', 'perfume', 'maquillaje'],
-            'dispositivos': ['dispositivo', 'equipo', 'instrumento', 'aparato', 'herramienta']
-        }
-    
-    def find_elements_by_semantic(self, soup: BeautifulSoup, pattern_type: str) -> List[Any]:
-        """Encuentra elementos usando patrones semánticos"""
-        if pattern_type not in self.semantic_patterns:
-            return []
-        
-        found_elements = []
-        patterns = self.semantic_patterns[pattern_type]
-        
-        for pattern in patterns:
-            elements = self._search_by_pattern(soup, pattern)
-            found_elements.extend(elements)
-            
-            # Si encontramos elementos, no necesitamos seguir buscando
-            if found_elements:
-                break
-        
-        return found_elements
-    
-    def _search_by_pattern(self, soup: BeautifulSoup, pattern: Dict[str, Any]) -> List[Any]:
-        """Busca elementos usando un patrón específico"""
-        elements = []
-        
-        for key, value in pattern.items():
-            if key == 'text':
-                # Buscar por texto
-                flags = 0 if pattern.get('case_sensitive', False) else re.IGNORECASE
-                regex = re.compile(value, flags)
-                elements.extend(soup.find_all(string=regex))
-                elements.extend([elem.parent for elem in soup.find_all(string=regex) if elem.parent])
-            
-            elif key == 'href':
-                # Buscar por href
-                flags = 0 if pattern.get('case_sensitive', False) else re.IGNORECASE
-                regex = re.compile(value, flags)
-                elements.extend(soup.find_all('a', href=regex))
-            
-            elif key == 'rel':
-                # Buscar por atributo rel
-                elements.extend(soup.find_all(attrs={'rel': value}))
+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.")
             
-            elif key == 'label':
-                # Buscar por etiquetas
-                flags = 0 if pattern.get('case_sensitive', False) else re.IGNORECASE
-                regex = re.compile(value, flags)
-                elements.extend(soup.find_all('label', string=regex))
-                elements.extend([elem.parent for elem in soup.find_all('label', string=regex) if elem.parent])
-        
-        return elements
-    
-    def extract_date_time(self, text: str) -> Tuple[str, str]:
-        """Extrae fecha y hora de un texto"""
-        if not text:
-            return "", ""
-        
-        fecha, hora = "", ""
-        
-        # Buscar fecha
-        for pattern in self.date_patterns:
-            match = re.search(pattern, text)
-            if match:
-                fecha = match.group()
-                break
-        
-        # Buscar hora
-        for pattern in self.time_patterns:
-            match = re.search(pattern, text)
-            if match:
-                hora = match.group()
-                break
-        
-        return fecha, hora
-    
-    def detect_themes(self, text: str) -> List[str]:
-        """Detecta temas automáticamente en el texto"""
-        if not text:
-            return []
-        
-        text_lower = text.lower()
-        themes = []
-        
-        for theme, keywords in self.theme_keywords.items():
-            if any(keyword in text_lower for keyword in keywords):
-                themes.append(theme)
-        
-        return themes
+        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
 
-# ==================== MOTOR DE EXTRACCIÓN ADAPTATIVO ====================
-class AdaptiveExtractor:
-    """Extractor adaptativo que maneja múltiples formatos de página"""
-    
-    def __init__(self):
-        self.detector = SemanticDetector()
-        self.fallback_strategies = [
-            self._extract_from_tables,
-            self._extract_from_divs,
-            self._extract_from_lists,
-            self._extract_from_text
-        ]
-    
-    def extract_detail_urls(self, soup: BeautifulSoup, base_url: str) -> List[str]:
-        """Extrae URLs de detalle usando múltiples estrategias"""
-        urls = set()
-        
-        # Estrategia 1: Detectar enlaces semánticamente
-        detail_links = self.detector.find_elements_by_semantic(soup, 'detail_link')
-        for link in detail_links:
-            if hasattr(link, 'get') and link.get('href'):
-                full_url = urljoin(base_url, link.get('href'))
-                urls.add(full_url)
-            elif hasattr(link, 'find'):
-                # Si es un elemento padre, buscar enlaces dentro
-                anchors = link.find_all('a', href=True)
-                for anchor in anchors:
-                    full_url = urljoin(base_url, anchor.get('href'))
-                    urls.add(full_url)
-        
-        # Estrategia 2: Buscar en tablas
-        tables = soup.find_all('table')
-        for table in tables:
-            links = table.find_all('a', href=True)
-            for link in links:
-                href = link.get('href')
-                if href and ('detalle' in href.lower() or '/audiencias/' in href):
-                    full_url = urljoin(base_url, href)
-                    urls.add(full_url)
-        
-        # Estrategia 3: Buscar por patrones de URL
-        all_links = soup.find_all('a', href=True)
-        for link in all_links:
-            href = link.get('href')
-            if href and re.search(r'/audiencias/\d+', href):
-                full_url = urljoin(base_url, href)
-                urls.add(full_url)
-        
-        return list(urls)
-    
-    def find_next_page(self, soup: BeautifulSoup, current_url: str, base_url: str) -> Optional[str]:
-        """Encuentra la siguiente página usando detectores semánticos"""
-        next_links = self.detector.find_elements_by_semantic(soup, 'next_page')
-        
-        for link in next_links:
-            if hasattr(link, 'get') and link.get('href'):
-                next_url = urljoin(base_url, link.get('href'))
-                if next_url != current_url:
-                    return next_url
-            elif hasattr(link, 'find'):
-                # Si es un elemento padre, buscar enlaces dentro
-                anchor = link.find('a', href=True)
-                if anchor:
-                    next_url = urljoin(base_url, anchor.get('href'))
-                    if next_url != current_url:
-                        return next_url
-        
-        return None
-    
-    def extract_detail_data(self, soup: BeautifulSoup, url: str) -> Dict[str, Any]:
-        """Extrae datos de detalle usando múltiples estrategias"""
-        data = {
-            'Identificador': url.split('/')[-1] if url else 'N/A',
-            'Link Audiencia': url,
-            'Fecha': '',
-            'Hora': '',
-            'Funcionario Nombre': '',
-            'Funcionario Cargo': '',
-            'Funcionario Código': '',
-            'Gestor Nombre': '',
-            'Gestor Empresa': '',
-            'Representados': '',
-            'Materia': '',
-            'Detalle': '',
-            'Participantes': '',
-            'Temas detectados': '',
-            'Forma': '',
-            'Lugar': '',
-            'Duración': ''
-        }
-        
-        # Aplicar estrategias en orden
-        for strategy in self.fallback_strategies:
+    def setup_driver(self):
+        print("Configurando el navegador virtual (Chrome)...")
+        options = webdriver.ChromeOptions()
+        options.add_argument("--headless")
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        options.add_argument("--disable-gpu")
+        options.add_argument("--window-size=1920x1080")
+        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")
+        
+        # Instala y configura el driver de Chrome automáticamente
+        service = ChromeService(ChromeDriverManager().install())
+        self.driver = webdriver.Chrome(service=service, options=options)
+        print("Navegador virtual configurado.")
+
+    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
+        
+        while True:
+            await asyncio.sleep(random.uniform(2, 4)) # Pequeña pausa para estabilidad
             try:
-                extracted = strategy(soup, url)
-                # Actualizar datos solo si la estrategia encontró algo
-                for key, value in extracted.items():
-                    if value and not data[key]:
-                        data[key] = value
+                # Espera a que la tabla o lista de audiencias sea visible
+                wait = WebDriverWait(self.driver, 20) # Aumentado a 20s
+                # Selector genérico 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")))
+                print(f"Contenido dinámico detectado en la página {page_num}.")
                 
-                # Si ya tenemos los datos básicos, no necesitamos más estrategias
-                if data['Fecha'] and data['Funcionario Nombre']:
-                    break
-            except Exception as e:
-                logger.warning(f"Error en estrategia {strategy.__name__}: {e}")
-                continue
-        
-        # Post-procesamiento
-        if data['Fecha'] and data['Hora']:
-            pass  # Ya están separados
-        elif data['Fecha']:
-            # Intentar separar fecha y hora si están juntas
-            fecha, hora = self.detector.extract_date_time(data['Fecha'])
-            data['Fecha'] = fecha
-            data['Hora'] = hora
-        
-        # Detectar temas
-        texto_completo = f"{data['Materia']} {data['Detalle']}"
-        themes = self.detector.detect_themes(texto_completo)
-        data['Temas detectados'] = ', '.join(themes)
-        
-        return data
-    
-    def _extract_from_tables(self, soup: BeautifulSoup, url: str) -> Dict[str, Any]:
-        """Extrae datos de tablas HTML"""
-        data = {}
-        tables = soup.find_all('table')
-        
-        for table in tables:
-            # Buscar tabla de información general
-            rows = table.find_all('tr')
-            for row in rows:
-                cells = row.find_all(['td', 'th'])
-                if len(cells) == 2:
-                    key = cells[0].get_text(strip=True).lower()
-                    value = cells[1].get_text(strip=True)
-                    
-                    if 'identificador' in key:
-                        data['Identificador'] = value
-                    elif 'fecha' in key:
-                        data['Fecha'] = value
-                    elif 'hora' in key:
-                        data['Hora'] = value
-                    elif 'forma' in key:
-                        data['Forma'] = value
-                    elif 'lugar' in key:
-                        data['Lugar'] = value
-                    elif 'duración' in key or 'duracion' in key:
-                        data['Duración'] = value
-                    elif 'materia' in key:
-                        data['Materia'] = value
-                    elif 'detalle' in key or 'especificación' in key:
-                        data['Detalle'] = value
-        
-        # Buscar tabla de asistentes
-        for table in tables:
-            headers = [th.get_text(strip=True).lower() for th in table.find_all('th')]
-            if any('asistente' in h or 'participante' in h for h in headers):
-                self._extract_participants_from_table(table, data)
-        
-        return data
-    
-    def _extract_from_divs(self, soup: BeautifulSoup, url: str) -> Dict[str, Any]:
-        """Extrae datos de divs y secciones"""
-        data = {}
-        
-        # Buscar por encabezados y contenido siguiente
-        for level in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
-            headers = soup.find_all(level)
-            for header in headers:
-                header_text = header.get_text(strip=True).lower()
-                next_element = header.find_next_sibling()
-                
-                if next_element:
-                    content = next_element.get_text(strip=True)
-                    
-                    if 'materia' in header_text:
-                        data['Materia'] = content
-                    elif 'detalle' in header_text or 'especificación' in header_text:
-                        data['Detalle'] = content
-                    elif 'funcionario' in header_text:
-                        data['Funcionario Nombre'] = content
-        
-        return data
-    
-    def _extract_from_lists(self, soup: BeautifulSoup, url: str) -> Dict[str, Any]:
-        """Extrae datos de listas"""
-        data = {}
-        
-        # Buscar listas definidas
-        for list_type in ['ul', 'ol', 'dl']:
-            lists = soup.find_all(list_type)
-            for lst in lists:
-                items = lst.find_all('li') if list_type in ['ul', 'ol'] else lst.find_all('dt')
-                for item in items:
-                    text = item.get_text(strip=True)
-                    if 'funcionario' in text.lower():
-                        data['Funcionario Nombre'] = text
-                    elif 'gestor' in text.lower():
-                        data['Gestor Nombre'] = text
-        
-        return data
-    
-    def _extract_from_text(self, soup: BeautifulSoup, url: str) -> Dict[str, Any]:
-        """Extrae datos del texto completo como último recurso"""
-        data = {}
-        
-        # Obtener todo el texto
-        full_text = soup.get_text()
-        
-        # Buscar patrones de fecha
-        fecha, hora = self.detector.extract_date_time(full_text)
-        if fecha:
-            data['Fecha'] = fecha
-        if hora:
-            data['Hora'] = hora
-        
-        # Buscar identificador en el título
-        title = soup.find('title')
-        if title:
-            title_text = title.get_text()
-            # Buscar patrón "Audiencias - Año XXXX - Nombre"
-            match = re.search(r'Audiencias\s*-\s*Año\s*\d+\s*-\s*(.+)', title_text)
-            if match:
-                data['Funcionario Nombre'] = match.group(1).strip()
-        
-        return data
-    
-    def _extract_participants_from_table(self, table: Any, data: Dict[str, Any]) -> None:
-        """Extrae participantes de una tabla"""
-        participants = []
-        headers = [th.get_text(strip=True).lower() for th in table.find_all('th')]
-        
-        # Encontrar índices de columnas relevantes
-        name_idx = next((i for i, h in enumerate(headers) if 'nombre' in h), 0)
-        quality_idx = next((i for i, h in enumerate(headers) if 'calidad' in h), 1)
-        empresa_idx = next((i for i, h in enumerate(headers) if 'empresa' in h or 'representado' in h), 2)
-        
-        rows = table.find_all('tr')[1:]  # Saltar encabezado
-        for row in rows:
-            cells = row.find_all('td')
-            if len(cells) > name_idx:
-                nombre = cells[name_idx].get_text(strip=True)
-                calidad = cells[quality_idx].get_text(strip=True) if len(cells) > quality_idx else ''
-                empresa = cells[empresa_idx].get_text(strip=True) if len(cells) > empresa_idx else ''
+                # 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}. Puede que el selector 'a[href*=\"/audiencias/detalle/\"]' sea incorrecto o no haya más audiencias.")
+
+                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)}")
                 
-                if nombre:
-                    participants.append(f"{nombre} ({calidad})")
-                    
-                    # Actualizar datos específicos
-                    if not data.get('Funcionario Nombre') and 'sujeto pasivo' in calidad.lower():
-                        data['Funcionario Nombre'] = nombre
-                    elif not data.get('Gestor Nombre') and 'gestor' in calidad.lower():
-                        data['Gestor Nombre'] = nombre
-                        data['Gestor Empresa'] = empresa
-                    elif not data.get('Representados') and empresa:
-                        data['Representados'] = empresa
-        
-        data['Participantes'] = '; '.join(participants)
+                # Intentar ir a la siguiente página
+                # Selector genérico para un botón de paginación "Siguiente". Si falla, es lo segundo a ajustar.
+                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
 
-# ==================== ESTRUCTURA DE DATOS ====================
-@dataclass
-class AudienciaData:
-    """Estructura normalizada para datos de audiencias"""
-    identificador: str
-    link: str
-    fecha: str
-    hora: str
-    funcionario_nombre: str
-    funcionario_cargo: str
-    funcionario_codigo: str
-    gestor_nombre: str
-    gestor_empresa: str
-    representados: str
-    materia: str
-    detalle: str
-    participantes: str
-    temas_detectados: str
-    forma: str = ""
-    lugar: str = ""
-    duracion: str = ""
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convierte a diccionario para DataFrame"""
-        return {
-            'Fecha': self.fecha,
-            'Hora': self.hora,
-            'Identificador Audiencia': self.identificador,
-            'Link Audiencia': self.link,
-            'Funcionario (nombre, cargo, código)': f"{self.funcionario_nombre} ({self.funcionario_cargo}, {self.funcionario_codigo})",
-            'Gestor de intereses (nombre, empresa)': f"{self.gestor_nombre} ({self.gestor_empresa})" if self.gestor_empresa else self.gestor_nombre,
-            'Representados': self.representados,
-            'Materia': self.materia,
-            'Detalle': self.detalle,
-            'Participantes (rol)': self.participantes,
-            'Temas detectados': self.temas_detectados,
-            'Forma': self.forma,
-            'Lugar': self.lugar,
-            'Duración': self.duracion
-        }
+            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"
+        
+        return list(all_detail_urls)
 
-# ==================== SCRAPER PRINCIPAL ====================
-class AdaptiveLeyLobbyScraper:
-    """Scraper 100% adaptativo para Ley Lobby"""
-    
-    def __init__(self, initial_url: str):
-        self.initial_url = initial_url
-        self.base_url = f"{urlparse(initial_url).scheme}://{urlparse(initial_url).netloc}"
-        self.extractor = AdaptiveExtractor()
-        self.institucion_codigo, self.anio = self._extract_url_info(initial_url)
-        self.all_data: List[AudienciaData] = []
-        
-    def _extract_url_info(self, url: str) -> Tuple[str, str]:
-        """Extrae información de institución y año de la URL"""
+    async def extract_audience_detail(self, detail_url):
         try:
-            path_parts = [p for p in urlparse(url).path.split('/') if p]
-            inst_index = path_parts.index('instituciones') + 1 if 'instituciones' in path_parts else -1
-            institucion = path_parts[inst_index] if inst_index < len(path_parts) else "unknown"
+            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")))
             
-            audiencias_index = path_parts.index('audiencias') + 1 if 'audiencias' in path_parts else -1
-            anio = path_parts[audiencias_index] if audiencias_index < len(path_parts) and path_parts[audiencias_index].isdigit() else "2025"
+            soup = BeautifulSoup(self.driver.page_source, 'html.parser')
             
-            return institucion, anio
-        except:
-            return "unknown", "2025"
-    
-    async def fetch_with_retry(self, url: str, max_retries: int = 3) -> Optional[str]:
-        """Fetch con reintentos y manejo robusto de errores"""
-        ssl_context = ssl.create_default_context()
-        ssl_context.check_hostname = False
-        ssl_context.verify_mode = ssl.CERT_NONE
-        
-        headers = {
-            'User-Agent': random.choice([
-                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-            ]),
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            'Accept-Language': 'es-ES,es;q=0.9,en;q=0.8',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Connection': 'keep-alive',
-            'Upgrade-Insecure-Requests': '1',
-            'Cache-Control': 'max-age=0'
-        }
-        
-        for attempt in range(max_retries):
-            try:
-                connector = aiohttp.TCPConnector(ssl=ssl_context, limit=10)
-                timeout = aiohttp.ClientTimeout(total=30)
-                
-                async with aiohttp.ClientSession(
-                    connector=connector, 
-                    headers=headers,
-                    timeout=timeout
-                ) as session:
-                    async with session.get(url) as response:
-                        if response.status == 200:
-                            content = await response.text()
-                            return content
-                        else:
-                            logger.warning(f"HTTP {response.status} para {url}")
-                            if attempt < max_retries - 1:
-                                await asyncio.sleep(2 ** attempt)
-                            continue
-                            
-            except Exception as e:
-                logger.error(f"Error fetching {url} (intento {attempt + 1}): {e}")
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(2 ** attempt)
-                continue
-        
-        return None
-    
-    async def discover_all_detail_urls(self) -> List[str]:
-        """Descubre todas las URLs de detalle paginando automáticamente"""
-        all_urls = set()
-        current_url = self.initial_url
-        processed_urls = set()
-        page_count = 0
-        
-        while current_url and current_url not in processed_urls:
-            processed_urls.add(current_url)
-            page_count += 1
+            data = {"Link Audiencia": detail_url, "Identificador Audiencia": detail_url.split('/')[-1]}
             
-            logger.info(f"Procesando página {page_count}: {current_url}")
+            # --- 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.
             
-            html = await self.fetch_with_retry(current_url)
-            if not html:
-                logger.error(f"No se pudo obtener contenido de {current_url}")
-                break
-                
-            soup = BeautifulSoup(html, 'html.parser')
+            # 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 ""
             
-            # Extraer URLs de detalle de esta página
-            page_urls = self.extractor.extract_detail_urls(soup, self.base_url)
-            all_urls.update(page_urls)
-            
-            logger.info(f"Encontradas {len(page_urls)} URLs en la página {page_count}")
-            
-            # Buscar siguiente página
-            next_url = self.extractor.find_next_page(soup, current_url, self.base_url)
-            current_url = next_url
+            # 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 ""
+
+            # 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})
             
-            # Pausa entre páginas
-            await asyncio.sleep(random.uniform(1, 3))
+            # 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)
             
-            # Límite de seguridad
-            if page_count > 50:
-                logger.warning("Se alcanzó el límite de páginas (50)")
-                break
-        
-        logger.info(f"Descubrimiento completo: {len(all_urls)} URLs únicas en {page_count} páginas")
-        return list(all_urls)
-    
-    async def extract_single_detail(self, url: str) -> AudienciaData:
-        """Extrae datos de una sola URL de detalle"""
-        html = await self.fetch_with_retry(url)
-        if not html:
-            return self._create_error_record(url, "Error al obtener página")
-        
-        soup = BeautifulSoup(html, 'html.parser')
-        
-        try:
-            # Usar extractor adaptativo
-            data = self.extractor.extract_detail_data(soup, url)
+            # 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)
             
-            # Crear registro de audiencia
-            return AudienciaData(
-                identificador=data['Identificador'],
-                link=data['Link Audiencia'],
-                fecha=data['Fecha'],
-                hora=data['Hora'],
-                funcionario_nombre=data['Funcionario Nombre'],
-                funcionario_cargo=data['Funcionario Cargo'],
-                funcionario_codigo=data['Funcionario Código'],
-                gestor_nombre=data['Gestor Nombre'],
-                gestor_empresa=data['Gestor Empresa'],
-                representados=data['Representados'],
-                materia=data['Materia'],
-                detalle=data['Detalle'],
-                participantes=data['Participantes'],
-                temas_detectados=data['Temas detectados'],
-                forma=data.get('Forma', ''),
-                lugar=data.get('Lugar', ''),
-                duracion=data.get('Duración', '')
-            )
+            return flattened_rows
             
         except Exception as e:
-            logger.error(f"Error extrayendo datos de {url}: {e}")
-            return self._create_error_record(url, str(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"}]
     
-    def _create_error_record(self, url: str, error_msg: str) -> AudienciaData:
-        """Crea un registro de error"""
-        return AudienciaData(
-            identificador=url.split('/')[-1] if url else "N/A",
-            link=url,
-            fecha=f"Error: {error_msg}",
-            hora="Error",
-            funcionario_nombre="Error",
-            funcionario_cargo="Error",
-            funcionario_codigo="Error",
-            gestor_nombre="Error",
-            gestor_empresa="Error",
-            representados="Error",
-            materia="Error",
-            detalle="Error",
-            participantes="Error",
-            temas_detectados="Error"
-        )
-    
-    async def run_complete_scraping(self):
-        """Ejecuta el scraping completo con reporte de progreso"""
-        logger.info("Iniciando scraping adaptativo completo...")
-        
-        # Fase 1: Descubrimiento de URLs
-        yield "🔍 Descubriendo URLs de audiencias...", "Analizando estructura del sitio", pd.DataFrame()
-        
-        detail_urls = await self.discover_all_detail_urls()
-        if not detail_urls:
-            yield "❌ No se encontraron URLs de detalle", "Error: Verificar URL inicial", pd.DataFrame()
-            return
-        
-        yield f"✅ Encontradas {len(detail_urls)} audiencias", f"Iniciando extracción de {len(detail_urls)} audiencias", pd.DataFrame()
-        
-        # Fase 2: Extracción de datos
-        semaphore = asyncio.Semaphore(5)  # Límite de concurrencia
-        
-        async def bounded_extract(url):
-            async with semaphore:
-                await asyncio.sleep(random.uniform(0.5, 2))
-                return await self.extract_single_detail(url)
-        
-        # Ejecutar extracciones
-        results = await asyncio.gather(*[bounded_extract(url) for url in detail_urls])
-        
-        self.all_data = results
-        
-        # Fase 3: Procesamiento y análisis
-        yield f"📊 Procesando {len(results)} audiencias...", "Generando análisis", pd.DataFrame()
-        
-        # Crear DataFrame para visualización
-        df_data = [audiencia.to_dict() for audiencia in self.all_data]
-        df = pd.DataFrame(df_data)
-        
-        # Mostrar muestra
-        preview_df = df.head(10) if not df.empty else pd.DataFrame()
-        
-        yield f"🎉 Scraping completado exitosamente!", f"Procesadas {len(self.all_data)} audiencias", preview_df
-    
-    def export_data(self) -> Tuple[Optional[str], Optional[str]]:
-        """Exporta los datos a archivos CSV y JSON"""
-        if not self.all_data:
-            return None, None
-        
-        # Convertir a DataFrame
-        df_data = [audiencia.to_dict() for audiencia in self.all_data]
-        df = pd.DataFrame(df_data)
-        
-        # Crear nombres de archivo
-        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")
-        json_filename = os.path.join(output_dir, f"leylobby_audiencias_{self.institucion_codigo}_{self.anio}_{timestamp}.json")
-        
+    async def run(self):
         try:
-            # Exportar CSV
-            df.to_csv(csv_filename, index=False, encoding='utf-8-sig')
-            
-            # Exportar JSON
-            json_data = [asdict(audiencia) for audiencia in self.all_data]
-            with open(json_filename, 'w', encoding='utf-8') as f:
-                json.dump(json_data, f, indent=2, ensure_ascii=False)
-            
-            return csv_filename, json_filename
-            
-        except Exception as e:
-            logger.error(f"Error exportando datos: {e}")
-            return None, None
-    
-    def generate_intelligence_report(self) -> str:
-        """Genera un reporte de inteligencia avanzado"""
-        if not self.all_data:
-            return "No hay datos para analizar"
-        
-        # Filtrar datos exitosos
-        successful_data = [d for d in self.all_data if not d.fecha.startswith('Error')]
-        
-        report = f"""
-# 🧠 REPORTE DE INTELIGENCIA LEY LOBBY
+            yield "Configurando navegador virtual...", "Procesando...", None, None, pd.DataFrame()
+            self.setup_driver()
 
-## 📊 ESTADÍSTICAS GENERALES
-- **Institución**: {self.institucion_codigo}
-- **Año**: {self.anio}
-- **Fecha de análisis**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-- **Total de audiencias procesadas**: {len(self.all_data)}
-- **Audiencias exitosas**: {len(successful_data)}
-- **Tasa de éxito**: {len(successful_data)/len(self.all_data)*100:.1f}%
+            yield "Recolectando URLs de detalle...", "Navegando y esperando JavaScript...", None, None, pd.DataFrame()
+            audiencia_detail_urls = await self.get_audience_detail_urls()
 
-## 🏢 GESTORES MÁS ACTIVOS
-"""
-        
-        if successful_data:
-            # Análisis de gestores/empresas
-            gestores = {}
-            for audiencia in successful_data:
-                gestor = audiencia.gestor_empresa or audiencia.gestor_nombre
-                if gestor and gestor != 'Error':
-                    gestores[gestor] = gestores.get(gestor, 0) + 1
+            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, pd.DataFrame()
+                 return
+
+            yield f"Recolectadas {len(audiencia_detail_urls)} URLs. Extrayendo detalles...", "Procesando...", None, None, pd.DataFrame()
             
-            top_gestores = sorted(gestores.items(), key=lambda x: x[1], reverse=True)[:15]
-            for i, (gestor, count) in enumerate(top_gestores, 1):
-                report += f"{i}. **{gestor}**: {count} audiencias\n"
+            tasks = [self.extract_audience_detail(url) for url in audiencia_detail_urls]
+            results = await asyncio.gather(*tasks)
             
-            # Análisis de funcionarios
-            report += "\n## 👥 FUNCIONARIOS MÁS SOLICITADOS\n"
-            funcionarios = {}
-            for audiencia in successful_data:
-                if audiencia.funcionario_nombre and audiencia.funcionario_nombre != 'Error':
-                    funcionarios[audiencia.funcionario_nombre] = funcionarios.get(audiencia.funcionario_nombre, 0) + 1
+            self.all_audiences_data = [item for sublist in results for item in sublist]
             
-            top_funcionarios = sorted(funcionarios.items(), key=lambda x: x[1], reverse=True)[:10]
-            for i, (funcionario, count) in enumerate(top_funcionarios, 1):
-                report += f"{i}. **{funcionario}**: {count} audiencias\n"
+            print(f"Extracción completa. Total de registros: {len(self.all_audiences_data)}")
             
-            # Análisis de temas
-            report += "\n## 🎯 TEMAS MÁS FRECUENTES\n"
-            temas_count = {}
-            for audiencia in successful_data:
-                if audiencia.temas_detectados and audiencia.temas_detectados != 'Error':
-                    temas = audiencia.temas_detectados.split(', ')
-                    for tema in temas:
-                        if tema.strip():
-                            temas_count[tema.strip()] = temas_count.get(tema.strip(), 0) + 1
+            # 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)']
+            for col in required_cols_final:
+                if col not in df.columns: df[col] = None
+            df = df[required_cols_final]
             
-            top_temas = sorted(temas_count.items(), key=lambda x: x[1], reverse=True)[:10]
-            for i, (tema, count) in enumerate(top_temas, 1):
-                report += f"{i}. **{tema}**: {count} menciones\n"
+            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"
             
-            # Análisis temporal
-            report += "\n## 📅 ANÁLISIS TEMPORAL\n"
-            fechas = [a.fecha for a in successful_data if a.fecha and not a.fecha.startswith('Error')]
-            if fechas:
-                report += f"- **Período cubierto**: {min(fechas)} a {max(fechas)}\n"
-                report += f"- **Total de fechas únicas**: {len(set(fechas))}\n"
-        
-        return report
+            if len(df) > len(df_success):
+                summary_analysis += f"**Audiencias con errores de extracción:** {len(df) - len(df_success)}\n"
 
-# ==================== INTERFAZ GRADIO ====================
-def create_ultimate_interface():
-    """Crea la interfaz definitiva"""
-    
-    with gr.Blocks(
-        title="🤖 Ley Lobby Scraper Definitivo",
-        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="gray")
-    ) as demo:
-        
-        gr.HTML("""
-        <div style="text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 20px; margin-bottom: 30px;">
-            <h1>🤖 Ley Lobby Scraper Definitivo</h1>
-            <p style="font-size: 18px;">Scraper 100% adaptativo que funciona HOY, MAÑANA y en 5 AÑOS</p>
-            <p style="font-size: 14px; opacity: 0.9;">No más selectores CSS rotos • Detección semántica • Inteligencia artificial</p>
-        </div>
-        """)
-        
-        gr.HTML("""
-        <div style="background: linear-gradient(135deg, #e8f5e8 0%, #f0f9ff 100%); border: 2px solid #10b981; border-radius: 15px; padding: 20px; margin: 20px 0;">
-            <h3 style="color: #065f46; margin-bottom: 15px;">🚀 Características Revolucionarias</h3>
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px;">
-                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <strong>🧠 Inteligencia Semántica</strong><br>
-                    <small>Entiende el contenido, no solo el CSS</small>
-                </div>
-                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <strong>🔍 Detección Automática</strong><br>
-                    <small>Encuentra elementos sin selectores fijos</small>
-                </div>
-                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <strong>🛡️ Resistente al Cambio</strong><br>
-                    <small>Funciona aunque cambien todo el sitio</small>
-                </div>
-                <div style="background: white; padding: 15px; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <strong>⚡ Múltiples Estrategias</strong><br>
-                    <small>Fallbacks automáticos si falla una</small>
-                </div>
-            </div>
-        </div>
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                url_input = gr.Textbox(
-                    label="🌐 URL de Audiencias",
-                    placeholder="https://www.leylobby.gob.cl/instituciones/AO001/audiencias/2025",
-                    info="Introduce cualquier URL de audiencias de cualquier institución y año",
-                    value="https://www.leylobby.gob.cl/instituciones/AO001/audiencias/2025"
-                )
+            # 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')
             
-            with gr.Column(scale=1):
-                scrape_btn = gr.Button(
-                    "🚀 Ejecutar Scraper Inteligente", 
-                    variant="primary", 
-                    size="lg",
-                    elem_id="scrape-button"
-                )
-        
-        with gr.Row():
-            with gr.Column():
-                status_output = gr.Textbox(
-                    label="📊 Estado del Proceso", 
-                    lines=2, 
-                    interactive=False,
-                    show_label=True
-                )
+            yield "Proceso finalizado.", summary_analysis, csv_filename, None, df_success.head(10)
             
-            with gr.Column():
-                progress_output = gr.Textbox(
-                    label="⏳ Progreso Detallado", 
-                    lines=2, 
-                    interactive=False,
-                    show_label=True
-                )
-        
-        analysis_output = gr.Markdown(
-            label="📋 Reporte de Inteligencia",
-            value="Ejecuta el scraper para ver el análisis completo..."
-        )
+        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, pd.DataFrame()
+        finally:
+            self.shutdown_driver()
+
+
+# --- Interfaz Gradio ---
+def create_interface():
+    with gr.Blocks(title="🤖 Ley Lobby Scraper Adaptativo", 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():
-            download_csv = gr.File(
-                label="📥 Descargar Datos CSV", 
-                interactive=False
-            )
-            download_json = gr.File(
-                label="📥 Descargar Datos JSON", 
-                interactive=False
-            )
+            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")
         
-        preview_table = gr.DataFrame(
-            label="👀 Vista Previa de Datos Extraídos",
-            interactive=False
-        )
-        
-        # Función principal del scraper
-        async def run_ultimate_scraper(url):
-            """Ejecuta el scraper definitivo"""
-            try:
-                # Validar URL
-                if not url or not url.startswith('http'):
-                    yield "❌ URL inválida", "Debe ser una URL completa", "", None, None, pd.DataFrame()
-                    return
-                
-                # Inicializar scraper
-                scraper = AdaptiveLeyLobbyScraper(url)
-                
-                # Ejecutar scraping con reporte de progreso
-                async for status, progress, preview_df in scraper.run_complete_scraping():
-                    yield status, progress, "", None, None, preview_df
-                
-                # Generar reporte de inteligencia
-                intelligence_report = scraper.generate_intelligence_report()
-                
-                # Exportar datos
-                csv_file, json_file = scraper.export_data()
-                
-                # Resultado final
-                yield (
-                    "✅ Scraping completado exitosamente!",
-                    f"Procesadas {len(scraper.all_data)} audiencias",
-                    intelligence_report,
-                    csv_file,
-                    json_file,
-                    preview_df
-                )
-                
-            except Exception as e:
-                error_msg = f"Error durante el scraping: {str(e)}"
-                yield error_msg, "Revisa la URL y la conexión", "", None, None, pd.DataFrame()
+        with gr.Group():
+            status_output = gr.Textbox(label="📊 Estado del Proceso", lines=3, interactive=False, autoscroll=True)
+            summary_output = gr.Markdown(label="📋 Resumen Ejecutivo")
         
-        # Conectar eventos
+        with gr.Row():
+            download_file_csv = gr.File(label="📥 Descargar Reporte CSV Completo", interactive=False)
+            preview_table = gr.DataFrame(label="👀 Vista Previa (Datos Exitosos)", 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, pd.DataFrame()
+                  return
+             try:
+                 scraper = SeleniumLobbyScraper(initial_url)
+                 async for status, summary, csv_file, _, preview_df in scraper.run():
+                      yield status, summary, csv_file, preview_df
+             except Exception as e:
+                 yield "Error Crítico", f"Error: {e}\n{traceback.format_exc()}", None, pd.DataFrame()
+                 
         scrape_btn.click(
-            fn=run_ultimate_scraper,
+            fn=run_task,
             inputs=[url_input],
-            outputs=[status_output, progress_output, analysis_output, download_csv, download_json, preview_table]
+            outputs=[status_output, summary_output, download_file_csv, preview_table]
         )
         
-        # Información adicional
-        gr.HTML("""
-        <div style="background: #f8fafc; border-radius: 15px; padding: 25px; margin: 25px 0;">
-            <h3 style="color: #374151; margin-bottom: 20px;">🔧 Cómo Funciona la Magia</h3>
-            
-            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px;">
-                <div style="background: white; padding: 20px; border-radius: 10px; border-left: 4px solid #3b82f6;">
-                    <h4 style="color: #1e40af; margin-bottom: 10px;">1. Detección Semántica</h4>
-                    <p style="color: #6b7280; font-size: 14px;">El sistema analiza el contenido y significado de los elementos, no solo su CSS. Busca palabras clave como "Ver Detalle", "Siguiente", "Fecha", etc.</p>
-                </div>
-                
-                <div style="background: white; padding: 20px; border-radius: 10px; border-left: 4px solid #10b981;">
-                    <h4 style="color: #065f46; margin-bottom: 10px;">2. Estrategias Múltiples</h4>
-                    <p style="color: #6b7280; font-size: 14px;">Si una estrategia falla, automáticamente prueba otra: tablas → divs → listas → texto completo. Nunca se rinde.</p>
-                </div>
-                
-                <div style="background: white; padding: 20px; border-radius: 10px; border-left: 4px solid #f59e0b;">
-                    <h4 style="color: #92400e; margin-bottom: 10px;">3. Adaptación Automática</h4>
-                    <p style="color: #6b7280; font-size: 14px;">Se ajusta automáticamente a cambios en la estructura del sitio. Si cambian los selectores, el scraper sigue funcionando.</p>
-                </div>
-                
-                <div style="background: white; padding: 20px; border-radius: 10px; border-left: 4px solid #ef4444;">
-                    <h4 style="color: #dc2626; margin-bottom: 10px;">4. Análisis Inteligente</h4>
-                    <p style="color: #6b7280; font-size: 14px;">Genera reportes automáticos con insights sobre actores clave, temas frecuentes y patrones de comportamiento.</p>
-                </div>
-            </div>
-            
-            <div style="margin-top: 25px; padding: 20px; background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%); border-radius: 10px;">
-                <h4 style="color: #92400e; margin-bottom: 10px;">🎯 Resultado Final</h4>
-                <p style="color: #78350f; font-size: 16px; margin: 0;">Un scraper que funciona HOY con la URL actual, funcionará MAÑANA cuando actualicen el sitio, y seguirá funcionando en 5 AÑOS cuando cambien completamente el diseño.</p>
-            </div>
-        </div>
-        """)
-        
-        gr.HTML("""
-        <div style="text-align: center; padding: 20px; color: #6b7280;">
-            <p>🚀 Desarrollado con inteligencia artificial adaptativa • 🛡️ Resistente a cambios • ⚡ Mantenimiento cero</p>
-        </div>
-        """)
-    
+        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
 
-# ==================== PUNTO DE ENTRADA ====================
+# --- Bloque principal para ejecutar la aplicación Gradio ---
 if __name__ == "__main__":
-    print("🚀 Iniciando Ley Lobby Scraper Definitivo...")
-    print("🧠 Cargando motores de inteligencia semántica...")
-    print("🔍 Inicializando detectores adaptativos...")
-    print("✅ Sistema listo para operar")
-    
-    try:
-        demo = create_ultimate_interface()
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            show_error=True,
-            show_api=False,
-            enable_queue=True
-        )
-    except Exception as e:
-        print(f"❌ Error iniciando la aplicación: {e}")
-        print("🔧 Verifica que todas las dependencias estén instaladas:")
-        print("   pip install aiohttp beautifulsoup4 pandas gradio")
+    # 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.")