Update app.py

app.py

@@ -32,27 +32,7 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 logger = logging.getLogger(__name__)
-def setup_spacy_model():
-    """Descarga el modelo de spaCy si no está instalado"""
-    try:
-        spacy.load("es_core_news_lg")
-        logger.info("Modelo spaCy 'es_core_news_lg' cargado correctamente")
-    except OSError:
-        logger.info("Descargando modelo spaCy 'es_core_news_lg'...")
-        try:
-            subprocess.run(
-                [sys.executable, "-m", "spacy", "download", "es_core_news_lg"],
-                check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-            logger.info("Modelo descargado exitosamente")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Error al descargar modelo: {e.stderr.decode()}")
-            raise RuntimeError("No se pudo descargar el modelo spaCy") from e
 
-# Configurar modelo antes de iniciar
-setup_spacy_model()
 class SEOSpaceAnalyzer:
     def __init__(self):
         self.session = self._configure_session()
@@ -60,20 +40,21 @@ class SEOSpaceAnalyzer:
         self.base_dir = Path("content_storage")
         self.base_dir.mkdir(parents=True, exist_ok=True)
         self.current_analysis = {}
+    
     def _load_models(self) -> Dict:
         """Carga modelos optimizados para Hugging Face"""
         try:
             device = 0 if torch.cuda.is_available() else -1
             return {
                 'summarizer': pipeline("summarization", model="facebook/bart-large-cnn", device=device),
-                'ner': pipeline("ner", model="dslim/bert-base-NER", device=device),
+                'ner': pipeline("ner", model="dslim/bert-base-NER", aggregation_strategy="simple", device=device),
                 'semantic': SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2'),
-                'spacy': spacy.load("es_core_news_lg")  # Ahora seguro que existe
+                'spacy': spacy.load("es_core_news_lg")
             }
         except Exception as e:
             logger.error(f"Error loading models: {e}")
             raise
-        
+    
     def _configure_session(self) -> requests.Session:
         """Configura sesión HTTP con reintentos"""
         session = requests.Session()
@@ -92,39 +73,15 @@ class SEOSpaceAnalyzer:
         })
         return session
     
-    def _load_models(self) -> Dict:
-        """Carga modelos optimizados para Hugging Face"""
-        try:
-            device = 0 if torch.cuda.is_available() else -1
-            return {
-                'summarizer': pipeline(
-                    "summarization", 
-                    model="facebook/bart-large-cnn",
-                    device=device
-                ),
-                'ner': pipeline(
-                    "ner", 
-                    model="dslim/bert-base-NER",
-                    aggregation_strategy="simple",
-                    device=device
-                ),
-                'semantic': SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2'),
-                'spacy': spacy.load("es_core_news_lg")
-            }
-        except Exception as e:
-            logger.error(f"Error loading models: {e}")
-            raise
-
-    def analyze_sitemap(self, sitemap_url: str) -> Dict:
-        """Analiza un sitemap completo"""
+    def analyze_sitemap(self, sitemap_url: str) -> Tuple[Dict, List[str], Dict, Dict]:
+        """Analiza un sitemap completo y devuelve componentes por separado"""
         try:
             urls = self._parse_sitemap(sitemap_url)
             if not urls:
-                return {"error": "No se pudieron extraer URLs del sitemap"}
+                return {"error": "No se pudieron extraer URLs del sitemap"}, [], {}, {}
             
             results = []
             with ThreadPoolExecutor(max_workers=4) as executor:
-                # Corregido: Cambiado ] por } en la comprensión del diccionario
                 futures = {executor.submit(self._process_url, url): url for url in urls[:20]}  # Limitar para demo
                 for future in as_completed(futures):
                     try:
@@ -142,11 +99,16 @@ class SEOSpaceAnalyzer:
                 'timestamp': datetime.now().isoformat()
             }
             
-            return self.current_analysis
+            return (
+                self.current_analysis['stats'],
+                self.current_analysis['recommendations'],
+                self.current_analysis['content_analysis'],
+                self.current_analysis['links']
+            )
             
         except Exception as e:
             logger.error(f"Error en análisis: {str(e)}")
-            return {"error": str(e)}
+            return {"error": str(e)}, [], {}, {}
     
     def _process_url(self, url: str) -> Dict:
         """Procesa una URL individual"""
@@ -332,8 +294,9 @@ class SEOSpaceAnalyzer:
         
         # Análisis de temas principales
         try:
+            stop_words = list(self.models['spacy'].Defaults.stop_words)
             vectorizer = TfidfVectorizer(
-                stop_words=list(spacy.lang.es.stop_words.STOP_WORDS),
+                stop_words=stop_words,
                 max_features=50,
                 ngram_range=(1, 2)
             )
@@ -404,9 +367,9 @@ class SEOSpaceAnalyzer:
         all_links = [link for r in results for link in r.get('links', [])]
         if all_links:
             df_links = pd.DataFrame(all_links)
-            broken_links = sum(1 for link in all_links if link['type'] == 'internal')
-            if broken_links > 5:  # Umbral arbitrario
-                recs.append(f"🔗 Revisar {broken_links} enlaces internos (posibles rotos)")
+            internal_links = df_links[df_links['type'] == 'internal']
+            if len(internal_links) > 100:  # Umbral arbitrario
+                recs.append(f"🔗 Optimizar estructura de enlaces internos ({len(internal_links)} enlaces)")
         
         return recs if recs else ["✅ No se detectaron problemas críticos de SEO"]
 
@@ -463,7 +426,7 @@ def create_interface():
                 ### Documentos Encontrados
                 Los documentos descargados se guardan en la carpeta `content_storage/`
                 """)
-                file_explorer = gr.FileExplorer(glob="content_storage/**/*")
+                # Reemplazado FileExplorer por Markdown informativo
         
         # Event handlers
         analyze_btn.click(
@@ -478,20 +441,27 @@ def create_interface():
             outputs=[stats_output, recommendations_output, content_output, links_output]
         )
         
+        # Para descargar el reporte, primero se debe generar
+        def generate_report():
+            if analyzer.current_analysis:
+                report_path = "content_storage/seo_report.json"
+                with open(report_path, 'w') as f:
+                    json.dump(analyzer.current_analysis, f, indent=2)
+                return report_path
+            return None
+        
         download_btn.click(
-            fn=lambda: gr.File(value="content_storage/seo_report.json"),
-            outputs=gr.File()
+            fn=generate_report,
+            outputs=gr.File(label="Descargar Reporte")
         )
         
     return interface
 
 if __name__ == "__main__":
-    # Verificar modelos antes de iniciar
     try:
         spacy.load("es_core_news_lg")
     except OSError:
-        logger.error("Modelo spaCy 'es_core_news_lg' no encontrado. Ejecute:")
-        logger.error("python -m spacy download es_core_news_lg")
+        logger.error("Modelo spaCy 'es_core_news_lg' no encontrado. Ejecute: python -m spacy download es_core_news_lg")
         exit(1)
     
     app = create_interface()