Update seo_analyzer.py

seo_analyzer.py

@@ -26,7 +26,6 @@ import matplotlib.pyplot as plt
 
 from utils import sanitize_filename
 
-# Configuración de logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
@@ -37,10 +36,6 @@ class SEOSpaceAnalyzer:
     def __init__(self, max_urls: int = 20, max_workers: int = 4) -> None:
         """
         Inicializa la sesión HTTP, carga modelos NLP y prepara el directorio de almacenamiento.
-        
-        Args:
-            max_urls: Número máximo de URLs a procesar por análisis.
-            max_workers: Número de hilos para la ejecución concurrente.
         """
         self.max_urls = max_urls
         self.max_workers = max_workers
@@ -66,23 +61,6 @@ class SEOSpaceAnalyzer:
         except Exception as e:
             logger.error(f"Error cargando modelos: {e}")
             raise
-    def plot_internal_links(self, links_data: dict) -> any:
-        """Genera un gráfico de barras horizontales mostrando los 20 principales enlaces internos."""
-        internal_links = links_data.get('internal_links', {})
-        if not internal_links:
-            # Crear una figura que indique que no hay datos
-            fig, ax = plt.subplots()
-            ax.text(0.5, 0.5, 'No hay enlaces internos', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes)
-            ax.axis('off')
-            return fig
-        fig, ax = plt.subplots()
-        names = list(internal_links.keys())
-        counts = list(internal_links.values())
-        ax.barh(names, counts)
-        ax.set_xlabel("Cantidad de enlaces")
-        ax.set_title("Top 20 Enlaces Internos")
-        plt.tight_layout()
-        return fig
 
     def _configure_session(self) -> requests.Session:
         """Configura una sesión HTTP con reintentos y headers personalizados."""
@@ -104,18 +82,7 @@ class SEOSpaceAnalyzer:
 
     def analyze_sitemap(self, sitemap_url: str) -> Tuple[Dict, List[str], Dict, Dict, List[Dict]]:
         """
-        Procesa el sitemap: extrae URLs, analiza cada página individualmente y devuelve datos agregados.
-        
-        Args:
-            sitemap_url: URL del sitemap XML.
-        
-        Returns:
-            Una tupla con 5 elementos:
-              - Estadísticas generales (dict)
-              - Recomendaciones SEO (lista de strings)
-              - Análisis de contenido agregado (dict)
-              - Análisis de enlaces (dict)
-              - Detalle individual de cada URL procesada (lista de dicts)
+        Procesa el sitemap: extrae URLs, analiza cada página y devuelve datos agregados.
         """
         try:
             urls = self._parse_sitemap(sitemap_url)
@@ -163,15 +130,18 @@ class SEOSpaceAnalyzer:
                 result.update({'type': 'unknown', 'content': '', 'word_count': 0})
             self._save_content(url, response.content)
             return result
-        except requests.exceptions.RequestException as e:
-            logger.warning(f"Error procesando {url}: {str(e)}")
-            return {'url': url, 'status': 'error', 'error': str(e)}
+        except requests.exceptions.Timeout as e:
+            logger.error(f"Timeout al procesar {url}: {e}")
+            return {'url': url, 'status': 'error', 'error': "Timeout"}
+        except requests.exceptions.HTTPError as e:
+            logger.error(f"HTTPError al procesar {url}: {e}")
+            return {'url': url, 'status': 'error', 'error': "HTTP Error"}
         except Exception as e:
-            logger.error(f"Error inesperado en {url}: {str(e)}")
+            logger.error(f"Error inesperado en {url}: {e}")
             return {'url': url, 'status': 'error', 'error': str(e)}
 
     def _process_html(self, html: str, base_url: str) -> Dict:
-        """Extrae y limpia el contenido HTML, metadatos y enlaces de la página."""
+        """Extrae y limpia el contenido HTML, metadatos y enlaces."""
         soup = BeautifulSoup(html, 'html.parser')
         clean_text = self._clean_text(soup.get_text())
         return {
@@ -198,9 +168,12 @@ class SEOSpaceAnalyzer:
                 'word_count': len(clean_text.split()),
                 'page_count': len(reader.pages)
             }
-        except PyPDF2.PdfReadError as e:
+        except PyPDF2.errors.PdfReadError as e:
             logger.error(f"Error leyendo PDF: {e}")
             return {'type': 'pdf', 'error': str(e)}
+        except Exception as e:
+            logger.error(f"Error procesando PDF: {e}")
+            return {'type': 'pdf', 'error': str(e)}
 
     def _clean_text(self, text: str) -> str:
         """Limpia y normaliza el texto removiendo espacios y caracteres especiales."""
@@ -210,7 +183,7 @@ class SEOSpaceAnalyzer:
         return re.sub(r'[^\w\sáéíóúñÁÉÍÓÚÑ]', ' ', text).strip()
 
     def _extract_metadata(self, soup: BeautifulSoup) -> Dict:
-        """Extrae metadatos relevantes (título, descripción, keywords, Open Graph) de la página."""
+        """Extrae metadatos relevantes de la página."""
         metadata = {'title': '', 'description': '', 'keywords': [], 'og': {}}
         if soup.title and soup.title.string:
             metadata['title'] = soup.title.string.strip()[:200]
@@ -227,7 +200,7 @@ class SEOSpaceAnalyzer:
         return metadata
 
     def _extract_links(self, soup: BeautifulSoup, base_url: str) -> List[Dict]:
-        """Extrae enlaces de la página, distinguiendo entre internos y externos."""
+        """Extrae y clasifica los enlaces internos y externos."""
         links: List[Dict] = []
         base_netloc = urlparse(base_url).netloc
         for tag in soup.find_all('a', href=True):
@@ -249,12 +222,12 @@ class SEOSpaceAnalyzer:
         return links
 
     def _get_file_type(self, path: str) -> str:
-        """Determina el tipo de archivo según la extensión."""
+        """Determina el tipo de archivo basado en la extensión."""
         ext = Path(path).suffix.lower()
         return ext[1:] if ext else 'html'
 
     def _parse_sitemap(self, sitemap_url: str) -> List[str]:
-        """Parsea un sitemap XML (y posibles índices de sitemaps) para extraer URLs."""
+        """Parsea un sitemap XML para extraer URLs."""
         try:
             response = self.session.get(sitemap_url, timeout=10)
             response.raise_for_status()
@@ -284,10 +257,11 @@ class SEOSpaceAnalyzer:
         try:
             parsed = urlparse(url)
             domain_dir = self.base_dir / parsed.netloc
-            path = parsed.path.lstrip('/')
-            if not path or path.endswith('/'):
-                path = os.path.join(path, 'index.html')
-            safe_path = sanitize_filename(path)
+            raw_path = parsed.path.lstrip('/')
+            # Si la ruta está vacía o termina en '/', asigna 'index.html'
+            if not raw_path or raw_path.endswith('/'):
+                raw_path = os.path.join(raw_path, 'index.html') if raw_path else 'index.html'
+            safe_path = sanitize_filename(raw_path)
             save_path = domain_dir / safe_path
             save_path.parent.mkdir(parents=True, exist_ok=True)
             new_hash = hashlib.md5(content).hexdigest()
@@ -319,7 +293,9 @@ class SEOSpaceAnalyzer:
         }
 
     def _analyze_content(self, results: List[Dict]) -> Dict:
-        """Genera un análisis de contenido agregado usando TF-IDF para extraer las palabras clave principales y muestras."""
+        """
+        Analiza el contenido agregado usando TF-IDF para extraer las palabras clave principales y muestras.
+        """
         successful = [r for r in results if r.get('status') == 'success' and r.get('content')]
         texts = [r['content'] for r in successful if len(r['content'].split()) > 10]
         if not texts:
@@ -338,7 +314,7 @@ class SEOSpaceAnalyzer:
         return {'top_keywords': top_keywords, 'content_samples': samples}
 
     def _analyze_links(self, results: List[Dict]) -> Dict:
-        """Genera un análisis de enlaces internos, dominios externos, anclas y tipos de archivos."""
+        """Genera un análisis de enlaces internos y externos."""
         all_links = []
         for result in results:
             if result.get('links'):
@@ -354,38 +330,4 @@ class SEOSpaceAnalyzer:
         }
 
     def _generate_seo_recommendations(self, results: List[Dict]) -> List[str]:
-        """Genera recomendaciones SEO en base a las deficiencias encontradas en el análisis."""
-        successful = [r for r in results if r.get('status') == 'success']
-        if not successful:
-            return ["No se pudo analizar ningún contenido exitosamente"]
-        recs = []
-        missing_titles = sum(1 for r in successful if not r.get('metadata', {}).get('title'))
-        if missing_titles:
-            recs.append(f"📌 Añadir títulos a {missing_titles} páginas")
-        short_descriptions = sum(1 for r in successful if not r.get('metadata', {}).get('description'))
-        if short_descriptions:
-            recs.append(f"📌 Añadir meta descripciones a {short_descriptions} páginas")
-        short_content = sum(1 for r in successful if r.get('word_count', 0) < 300)
-        if short_content:
-            recs.append(f"📝 Ampliar contenido en {short_content} páginas (menos de 300 palabras)")
-        all_links = [link for r in results for link in r.get('links', [])]
-        if all_links:
-            df_links = pd.DataFrame(all_links)
-            internal_links = df_links[df_links['type'] == 'internal']
-            if len(internal_links) > 100:
-                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"]
-
-    def plot_internal_links(self, links_data: Dict) -> Any:
-        """Genera un gráfico de barras horizontales mostrando los 20 principales enlaces internos."""
-        internal_links = links_data.get('internal_links', {})
-        if not internal_links:
-            return {}
-        fig, ax = plt.subplots()
-        names = list(internal_links.keys())
-        counts = list(internal_links.values())
-        ax.barh(names, counts)
-        ax.set_xlabel("Cantidad de enlaces")
-        ax.set_title("Top 20 Enlaces Internos")
-        plt.tight_layout()
-        return fig
+        """Genera recomendaciones SEO basadas en las deficiencias encontr