Update web_scraper_tool.py

web_scraper_tool.py

@@ -1,22 +1,36 @@
-# web_scraper_tool.py
 # -*- coding: utf-8 -*-
 import requests
 from bs4 import BeautifulSoup
-from fpdf import FPDF, FPDFException # Importar FPDFException
+from fpdf import FPDF, FPDFException
 from urllib.parse import urlparse, urlunparse
 import tempfile
 import os
-import re # Para expresiones regulares
+import re
+from requests.adapters import HTTPAdapter
+# from requests.packages.urllib3.util.retry import Retry # Para versiones más antiguas de requests
+from urllib3.util.retry import Retry # Para requests >= 2.26 o si urllib3 está instalado globalmente
 
 class WebScrapperTool:
     def __init__(self):
         self.session = requests.Session()
+        
+        # Configurar estrategia de reintentos
+        retry_strategy = Retry(
+            total=3,  # Número total de reintentos
+            backoff_factor=1,  # Factor de espera (ej. 1s, 2s, 4s entre reintentos)
+            status_forcelist=[429, 500, 502, 503, 504], # Códigos HTTP que dispararán un reintento
+            allowed_methods=["HEAD", "GET", "OPTIONS"] # Métodos HTTP para los que se aplicarán reintentos
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
         self.session.headers.update({
             "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
         })
         
         self.dejavu_regular_path = self._find_font_file('DejaVuSansCondensed.ttf')
-        self.dejavu_bold_path = self._find_font_file('DejaVuSansCondensed-Bold.ttf') # Intentar encontrar la negrita
+        self.dejavu_bold_path = self._find_font_file('DejaVuSansCondensed-Bold.ttf')
 
         if not self.dejavu_regular_path:
             print("Advertencia: No se encontró 'DejaVuSansCondensed.ttf'. Se usará Arial para el cuerpo de los PDFs (soporte Unicode limitado).")
@@ -24,9 +38,7 @@ class WebScrapperTool:
         if self.dejavu_regular_path and not self.dejavu_bold_path:
             print("Advertencia: No se encontró 'DejaVuSansCondensed-Bold.ttf'. Los títulos en PDF usarán Arial Bold o DejaVu Regular si Arial falla.")
 
-
     def _find_font_file(self, font_filename: str):
-        """Busca un archivo de fuente específico."""
         if os.path.exists(font_filename):
             return font_filename
         if os.path.exists(os.path.join('fonts', font_filename)):
@@ -39,33 +51,23 @@ class WebScrapperTool:
         
         scheme = parsed_url.scheme
         if not scheme:
-            # Si no hay esquema pero el netloc parece una URL sin esquema (ej. www.google.com)
-            if parsed_url.netloc:
+            if parsed_url.netloc: # ej. www.google.com/page
                  parsed_url = parsed_url._replace(scheme="https")
-            # Si no hay netloc pero el path parece una URL (ej. www.google.com/page)
-            elif parsed_url.path and '.' in parsed_url.path.split('/')[0]:
+            elif parsed_url.path and '.' in parsed_url.path.split('/')[0]: # ej. google.com/page
                 path_parts = parsed_url.path.split('/')
                 potential_netloc = path_parts[0]
                 new_path = '/'.join(path_parts[1:])
                 parsed_url = parsed_url._replace(scheme="https", netloc=potential_netloc, path=new_path)
-            # Si es solo un path (ej. page.html), esto es más ambiguo y podría ser un archivo local.
-            # Para este scraper, asumimos que se refiere a una URL y necesita un esquema.
-            else:
+            else: # ej. page.html or /page.html
                  parsed_url = parsed_url._replace(scheme="https")
         
-        # Asegurarse que el netloc no esté vacío si hay un path que no es absoluto para el netloc
-        if not parsed_url.netloc and parsed_url.path:
-            if '.' in parsed_url.path.split('/')[0] and not parsed_url.path.startswith('/'):
-                 # Heurística: si 'algo.com/path' vino sin 'http://', path contendrá 'algo.com/path'
-                 # y netloc estará vacío. Lo corregimos.
-                path_parts = parsed_url.path.split('/')
-                new_netloc = path_parts[0]
-                new_path = '/' + '/'.join(path_parts[1:]) if len(path_parts) > 1 else ''
-                # Solo si el scheme no fue forzado a https y netloc sigue vacío.
-                # Esto es complicado, la lógica anterior de agregar https si no hay scheme debería cubrirlo.
-                # La línea siguiente es una verificación adicional.
-                if not parsed_url.scheme and not parsed_url.netloc:
-                     parsed_url = parsed_url._replace(netloc=new_netloc, path=new_path, scheme="https")
+        if not parsed_url.netloc and parsed_url.path and not parsed_url.path.startswith('/'):
+            # Caso como "google.com" que termina en path sin netloc si no hubo "www."
+            if '.' in parsed_url.path and '/' not in parsed_url.path: # "google.com"
+                parsed_url = parsed_url._replace(netloc=parsed_url.path, path='')
+            elif '.' in parsed_url.path.split('/')[0]: # "google.com/path"
+                parts = parsed_url.path.split('/', 1)
+                parsed_url = parsed_url._replace(netloc=parts[0], path=f"/{parts[1]}" if len(parts) > 1 else '')
 
 
         return urlunparse(parsed_url)
@@ -75,104 +77,105 @@ class WebScrapperTool:
         try:
             parsed_url = urlparse(url)
             return any(parsed_url.path.lower().endswith(ext) for ext in image_extensions)
-        except Exception: # En caso de URL muy malformada que urlparse no pueda manejar
+        except Exception:
             return False
 
-
     def _get_content(self, url: str):
         try:
             is_potential_image = self.is_image_url(url)
-            response = self.session.get(url, timeout=20, allow_redirects=True, stream=is_potential_image)
-            response.raise_for_status()
+            # Timeouts: (connect_timeout, read_timeout) en segundos. Aplicado a cada intento.
+            response = self.session.get(url, timeout=(15, 30), allow_redirects=True, stream=is_potential_image)
+            response.raise_for_status() # Lanza HTTPError para códigos 4xx/5xx después de reintentos (si aplica)
             
             content_type_header = response.headers.get('content-type', '').lower()
 
-            if 'image' in content_type_header or (is_potential_image and not content_type_header):
-                # Si el content_type es genérico pero la URL sugiere imagen (ej. octet-stream para un .jpg)
+            if 'image' in content_type_header or (is_potential_image and not content_type_header.startswith('text/')):
                 raw_content = response.content 
-                return None, raw_content, content_type_header or "image/unknown" # Proporcionar un content_type de imagen si estaba vacío
+                return None, raw_content, content_type_header or "image/unknown"
 
-            # Para contenido no imagen, intentar decodificar.
             text_content = None
             try:
+                # Intentar decodificar como UTF-8 primero
                 text_content = response.content.decode('utf-8')
             except UnicodeDecodeError:
-                # Si UTF-8 falla, usar la codificación que requests detecta (puede ser UTF-8 también si fue especificada en headers)
-                # o su heurística.
+                # Si UTF-8 falla, usar la codificación que 'requests' infiere (almacenada en response.text)
                 print(f"Advertencia: Falló la decodificación UTF-8 para {url}. Usando response.text (codificación aparente: {response.apparent_encoding}).")
-                text_content = response.text 
+                text_content = response.text # response.text usa la codificación detectada por requests
             
             return text_content, response.content, content_type_header
-        except requests.exceptions.Timeout:
-            return None, None, f"Error: Timeout al intentar acceder a la URL: {url}"
-        except requests.exceptions.TooManyRedirects:
-            return None, None, f"Error: Demasiados redirects para la URL: {url}"
-        except requests.exceptions.SSLError:
-            return None, None, f"Error: Problema de SSL con la URL: {url}. Intenta con http:// o verifica el certificado."
-        except requests.exceptions.RequestException as e:
-            return None, None, f"Error de conexión/HTTP: {str(e)}"
-        except Exception as e_generic: # Captura general para errores inesperados durante la obtención
+        
+        except requests.exceptions.ConnectTimeout as e:
+            return None, None, f"Error: Timeout de conexión al acceder a {url}. El servidor no respondió a la solicitud de conexión a tiempo (después de reintentos). (Detalle: {str(e)})"
+        except requests.exceptions.ReadTimeout as e:
+            return None, None, f"Error: Timeout de lectura al acceder a {url}. El servidor conectó pero tardó demasiado en enviar datos (después de reintentos). (Detalle: {str(e)})"
+        except requests.exceptions.Timeout as e: # Captura otros Timeouts (si los hay) que no sean Connect o Read.
+            return None, None, f"Error: Timeout general al intentar acceder a la URL: {url} (después de reintentos). (Detalle: {str(e)})"
+        except requests.exceptions.HTTPError as e: # Errores HTTP como 403, 404, 500 (si no se reintentaron o fallaron tras reintentos)
+             return None, None, f"Error HTTP {e.response.status_code} ({e.response.reason}) para la URL: {url}. (Detalle: {str(e)})"
+        except requests.exceptions.TooManyRedirects as e:
+            return None, None, f"Error: Demasiados redirects para la URL: {url}. (Detalle: {str(e)})"
+        except requests.exceptions.SSLError as e:
+            return None, None, f"Error: Problema de SSL con la URL: {url}. (Detalle: {str(e)})"
+        except requests.exceptions.ConnectionError as e: # Cubre otros problemas de conexión (DNS, etc.)
+            return None, None, f"Error de conexión al intentar acceder a {url}. (Detalle: {str(e)})"
+        except requests.exceptions.RequestException as e: # Captura base para otros errores de requests no cubiertos
+            return None, None, f"Error de red/petición: {str(e)}"
+        except Exception as e_generic: 
+            import traceback
+            tb_str = traceback.format_exc()
+            print(f"Error inesperado en _get_content para URL {url}: {str(e_generic)}\n{tb_str}")
             return None, None, f"Error inesperado obteniendo contenido: {str(e_generic)}"
 
-
     def scrape_to_text(self, url: str):
         text_content, _, content_type_info = self._get_content(url)
 
-        # Si _get_content devolvió un mensaje de error en content_type_info
         if text_content is None and isinstance(content_type_info, str) and content_type_info.startswith("Error:"):
             return {'status': 'error', 'message': content_type_info, 'url': url}
 
         final_text = ""
-        if text_content: # Solo procesar si text_content no es None
-            if 'text/html' in content_type_info:
+        if text_content:
+            content_type_str = str(content_type_info) # Asegurar que es string
+            if 'text/html' in content_type_str:
                 soup = BeautifulSoup(text_content, 'html.parser')
-                # Eliminar elementos no deseados
                 for element in soup(["script", "style", "nav", "footer", "aside", "form", "button", "input", "header", "noscript", "iframe", "link", "meta"]):
-                    element.decompose()
+                    if element: element.decompose()
                 
-                # Intentar obtener el contenido principal, si no, el cuerpo, si no, todo el texto parseable
-                main_content_tags = ['main', 'article', 'div[role="main"]', 'div[class*="content"]', 'div[id*="content"]']
+                main_content_tags = ['main', 'article', 'div[role="main"]', 'div[class*="content"]', 'div[id*="content"]', 'section[class*="content"]']
                 content_holder = None
                 for tag_selector in main_content_tags:
                     try:
-                        content_holder = soup.select_one(tag_selector)
-                        if content_holder:
+                        candidate = soup.select_one(tag_selector)
+                        if candidate:
+                            content_holder = candidate
                             break
-                    except Exception: # select_one puede fallar con selectores malformados aunque aquí son fijos
-                        pass
+                    except Exception: pass
                 
-                if not content_holder:
-                    content_holder = soup.find('body')
+                if not content_holder: content_holder = soup.find('body')
                 
-                if content_holder:
-                    text_items = [s.strip() for s in content_holder.stripped_strings if s.strip()]
-                    final_text = "\n".join(text_items)
-                else: # Fallback si no se encuentra body o main (ej. fragmento HTML)
-                    text_items = [s.strip() for s in soup.stripped_strings if s.strip()]
-                    final_text = "\n".join(text_items)
+                if content_holder: text_items = [s.strip() for s in content_holder.stripped_strings if s.strip()]
+                else: text_items = [s.strip() for s in soup.stripped_strings if s.strip()]
+                final_text = "\n".join(text_items)
             
-            elif 'text/plain' in content_type_info:
+            elif 'text/plain' in content_type_str:
                 final_text = text_content
-            elif self.is_image_url(url) or ('image' in content_type_info):
+            elif self.is_image_url(url) or ('image' in content_type_str):
                 return {'status': 'error', 'message': f"La URL apunta a una imagen. El formato TXT es para contenido textual. Intente el formato PDF para imágenes.", 'url': url}
-            else: # Otros tipos de texto que no son html o plain (ej. xml, json)
-                # Podríamos intentar extraer texto de JSON/XML aquí si fuera necesario
-                # Por ahora, simplemente tomamos el contenido como está si es texto.
+            else: 
                 final_text = text_content
-        else: # text_content es None y no fue un error de _get_content
+        else:
              error_message = f"No se pudo obtener contenido textual de la URL (Tipo: {content_type_info})."
-             if isinstance(content_type_info, str) and content_type_info.startswith("Error:"): # Doble check
+             if isinstance(content_type_info, str) and content_type_info.startswith("Error:"):
                  error_message = content_type_info
              return {'status': 'error', 'message': error_message, 'url': url}
 
-
         if not final_text.strip():
             return {'status': 'error', 'message': "No se encontró contenido textual extraíble o la página está vacía después de la limpieza.", 'url': url}
 
         try:
-            # Usar un nombre de archivo más descriptivo si es posible
-            safe_filename_prefix = re.sub(r'[^a-zA-Z0-9_-]', '_', urlparse(url).netloc + urlparse(url).path)
-            safe_filename_prefix = safe_filename_prefix[:50] # Limitar longitud
+            parsed_url_obj = urlparse(url)
+            safe_filename_base = (parsed_url_obj.netloc + parsed_url_obj.path).replace('/', '_').replace(':', '_')
+            safe_filename_prefix = re.sub(r'[^a-zA-Z0-9_-]', '', safe_filename_base)
+            safe_filename_prefix = safe_filename_prefix[:50]
 
             with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', encoding='utf-8', prefix=f"scraped_{safe_filename_prefix}_") as tmp_file:
                 tmp_file.write(f"URL: {url}\n\n--- Contenido ---\n\n{final_text}")
@@ -184,33 +187,39 @@ class WebScrapperTool:
     def scrape_to_pdf(self, url: str):
         text_content, raw_content, content_type_info = self._get_content(url)
 
-        if text_content is None and raw_content is None: # Error al obtener contenido
-             # content_type_info aquí es el mensaje de error
-            return {'status': 'error', 'message': content_type_info, 'url': url}
+        if text_content is None and raw_content is None:
+            return {'status': 'error', 'message': str(content_type_info), 'url': url}
+
+        content_type_str = str(content_type_info) # Asegurar que es string
+        is_likely_image = 'image' in content_type_str or \
+                          (self.is_image_url(url) and ('octet-stream' in content_type_str or not content_type_str or content_type_str == "application/unknown"))
 
-        is_likely_image = 'image' in content_type_info or (self.is_image_url(url) and 'octet-stream' in content_type_info)
 
         if is_likely_image and raw_content:
-            tmp_img_path = None # Para asegurar que se pueda eliminar en el finally
+            tmp_img_path = None
             try:
                 pdf = FPDF()
                 pdf.add_page()
                 
-                img_suffix = '.' + content_type_info.split('/')[-1].split(';')[0].strip()
-                if img_suffix in ['.', '.unknown']: img_suffix = '.jpg' # Fallback
-                
+                img_ext_from_content_type = content_type_str.split('/')[-1].split(';')[0].strip()
+                if img_ext_from_content_type in ["unknown", "octet-stream"] or not img_ext_from_content_type: # Check for generic or empty
+                    parsed_url_path = urlparse(url).path
+                    img_ext_from_url = os.path.splitext(parsed_url_path)[1].lower()
+                    img_suffix = img_ext_from_url if img_ext_from_url else '.jpg' # Fallback
+                else:
+                    img_suffix = '.' + img_ext_from_content_type
+
                 valid_img_suffixes = ['.jpeg', '.jpg', '.png']
                 if img_suffix not in valid_img_suffixes:
-                    if 'png' in content_type_info: img_suffix = '.png'
-                    elif 'jpeg' in content_type_info or 'jpg' in content_type_info: img_suffix = '.jpg'
-                    else: img_suffix = '.jpg' # Fallback general
+                    if 'png' in content_type_str or img_suffix == '.png': img_suffix = '.png'
+                    elif 'jpeg' in content_type_str or 'jpg' in content_type_str or img_suffix == '.jpg' or img_suffix == '.jpeg': img_suffix = '.jpg'
+                    else: img_suffix = '.jpg' 
 
                 with tempfile.NamedTemporaryFile(delete=False, suffix=img_suffix) as tmp_img:
                     tmp_img.write(raw_content)
                     tmp_img_path = tmp_img.name
                 
                 page_width = pdf.w - 2 * pdf.l_margin
-                # Intentar añadir imagen. Si falla por formato, FPDFException se captura abajo.
                 pdf.image(tmp_img_path, x=pdf.l_margin, y=pdf.t_margin, w=page_width)
 
                 with tempfile.NamedTemporaryFile(delete=False, mode='wb', suffix='.pdf') as tmp_file:
@@ -218,8 +227,7 @@ class WebScrapperTool:
                     tmp_file.write(pdf_bytes)
                     filepath = tmp_file.name
                 return {'status': 'success', 'file': filepath, 'url': url}
-
-            except FPDFException as fpdf_e: # Errores específicos de FPDF (ej. formato de imagen no soportado)
+            except FPDFException as fpdf_e:
                 return {'status': 'error', 'message': f"Error de FPDF al procesar imagen (formato {img_suffix} podría no ser compatible o imagen corrupta): {str(fpdf_e)}", 'url': url}
             except Exception as e_img:
                 import traceback
@@ -227,39 +235,35 @@ class WebScrapperTool:
             finally:
                 if tmp_img_path and os.path.exists(tmp_img_path):
                      os.unlink(tmp_img_path)
-
-        # Procesamiento de texto para PDF
+        
         extracted_text_for_pdf = ""
-        if text_content: # Solo procesar si text_content no es None
-            if 'text/html' in content_type_info:
+        if text_content:
+            if 'text/html' in content_type_str:
                 soup = BeautifulSoup(text_content, 'html.parser')
                 for element in soup(["script", "style", "nav", "footer", "aside", "form", "button", "input", "header", "noscript", "iframe", "link", "meta"]):
-                    element.decompose()
+                    if element: element.decompose()
                 
-                main_content_tags = ['main', 'article', 'div[role="main"]', 'div[class*="content"]', 'div[id*="content"]']
+                main_content_tags = ['main', 'article', 'div[role="main"]', 'div[class*="content"]', 'div[id*="content"]', 'section[class*="content"]']
                 content_holder = None
                 for tag_selector in main_content_tags:
                     try:
-                        content_holder = soup.select_one(tag_selector)
-                        if content_holder:
+                        candidate = soup.select_one(tag_selector)
+                        if candidate: 
+                            content_holder = candidate
                             break
-                    except Exception:
-                        pass
-                if not content_holder:
-                    content_holder = soup.find('body')
-
-                if content_holder:
-                    text_items = [s.strip() for s in content_holder.stripped_strings if s.strip()]
-                    extracted_text_for_pdf = "\n".join(text_items)
-                else:
-                    extracted_text_for_pdf = "\n".join([s.strip() for s in soup.stripped_strings if s.strip()])
+                    except Exception: pass
+                if not content_holder: content_holder = soup.find('body')
+
+                if content_holder: text_items = [s.strip() for s in content_holder.stripped_strings if s.strip()]
+                else: text_items = [s.strip() for s in soup.stripped_strings if s.strip()]
+                extracted_text_for_pdf = "\n".join(text_items)
             
-            elif 'text/plain' in content_type_info:
+            elif 'text/plain' in content_type_str:
                 extracted_text_for_pdf = text_content
-            else: # Otros tipos de texto
+            else:
                  extracted_text_for_pdf = text_content
-        else: # text_content es None, y no es una imagen (ya manejado arriba)
-            error_message = content_type_info if isinstance(content_type_info, str) and content_type_info.startswith("Error:") else f"Tipo de contenido no soportado o vacío para PDF: {content_type_info}"
+        else:
+            error_message = content_type_str if isinstance(content_type_str, str) and content_type_str.startswith("Error:") else f"Tipo de contenido no soportado o vacío para PDF: {content_type_str}"
             return {'status': 'error', 'message': error_message, 'url': url}
 
         if not extracted_text_for_pdf.strip():
@@ -270,98 +274,87 @@ class WebScrapperTool:
             pdf.add_page()
             pdf.set_auto_page_break(auto=True, margin=15)
 
-            # Preparar fuentes
             title_font_family = 'Arial'
             title_font_style = 'B'
             body_font_family = 'Arial'
             body_font_style = ''
 
+            font_error_occurred = False
             if self.dejavu_regular_path:
-                pdf.add_font('DejaVu', '', self.dejavu_regular_path, uni=True)
-                body_font_family = 'DejaVu' # Usar DejaVu para el cuerpo
-                title_font_family = 'DejaVu' # Intentar DejaVu para el título también
-                
-                if self.dejavu_bold_path:
-                    pdf.add_font('DejaVu', 'B', self.dejavu_bold_path, uni=True)
-                    title_font_style = 'B' # Negrita DejaVu disponible
-                else:
-                    title_font_style = '' # No hay DejaVu negrita, usar DejaVu regular para el título o Arial Bold
-                                          # Vamos a priorizar Arial Bold si DejaVu Bold no está.
-
-            # Configurar fuente del título
-            if title_font_family == 'DejaVu' and title_font_style == 'B' and not self.dejavu_bold_path:
-                # Si queríamos DejaVu Bold pero no está, usamos Arial Bold
-                pdf.set_font('Arial', 'B', 12)
-            else:
-                # Usar la combinación de DejaVu (Regular o Bold) o Arial Bold si DejaVu no está
-                pdf.set_font(title_font_family, title_font_style, 12)
+                try:
+                    pdf.add_font('DejaVu', '', self.dejavu_regular_path, uni=True)
+                    body_font_family = 'DejaVu'
+                    title_font_family = 'DejaVu'
+                    if self.dejavu_bold_path:
+                        pdf.add_font('DejaVu', 'B', self.dejavu_bold_path, uni=True)
+                        title_font_style = 'B'
+                    else:
+                        title_font_style = '' # Use regular DejaVu if bold not found
+                except FPDFException as fe:
+                    print(f"Error al añadir fuente DejaVu: {fe}. Usando Arial.")
+                    font_error_occurred = True
+                    title_font_family, body_font_family = 'Arial', 'Arial'
+                    title_font_style = 'B' # Arial bold para título
             
-            # Escribir URL como título
-            # Limpiar URL de caracteres no imprimibles antes de pasarla a multi_cell
+            if title_font_family == 'DejaVu' and title_font_style == 'B' and (not self.dejavu_bold_path or font_error_occurred) :
+                pdf.set_font('Arial', 'B', 12) # Fallback a Arial Bold si DejaVu Bold no está o falló
+            else:
+                try:
+                    pdf.set_font(title_font_family, title_font_style, 12)
+                except FPDFException: # Si set_font falla incluso con DejaVu regular (raro si add_font tuvo éxito)
+                    pdf.set_font('Arial', 'B', 12) # Fallback final a Arial
+
+
             clean_url_for_pdf = "".join(c for c in url if c.isprintable() or c in ('\n', '\r', '\t'))
             try:
-                pdf.multi_cell(0, 8, f"Contenido de: {clean_url_for_pdf}") # Usar la URL limpia
+                pdf.multi_cell(0, 8, f"Contenido de: {clean_url_for_pdf}")
             except FPDFException as e_url_font:
-                # Si incluso con Arial falla por un carácter en la URL (muy raro)
-                print(f"Advertencia: Error al escribir URL en PDF con fuente {title_font_family}{title_font_style}: {e_url_font}. Usando placeholder.")
-                pdf.set_font('Arial', 'B', 12) # Reintentar con Arial seguro
+                print(f"Advertencia: Error al escribir URL en PDF: {e_url_font}. Usando placeholder.")
+                pdf.set_font('Arial', 'B', 12) 
                 pdf.multi_cell(0, 8, f"Contenido de URL (ver metadatos)")
+            pdf.ln(6)
 
+            try:
+                pdf.set_font(body_font_family, body_font_style, 11)
+            except FPDFException: # Si falla la fuente del cuerpo
+                 pdf.set_font('Arial', '', 11)
 
-            pdf.ln(6)
 
-            # Configurar fuente del cuerpo
-            pdf.set_font(body_font_family, body_font_style, 11)
-            
-            # Limpieza básica de caracteres problemáticos comunes
             clean_text = extracted_text_for_pdf.replace('\u2013', '-').replace('\u2014', '--')
             clean_text = clean_text.replace('\u2018', "'").replace('\u2019', "'")
             clean_text = clean_text.replace('\u201c', '"').replace('\u201d', '"')
-            clean_text = clean_text.replace('\u2026', '...')
-            clean_text = clean_text.replace('\u00A0', ' ') # Non-breaking space
+            clean_text = clean_text.replace('\u2026', '...').replace('\u00A0', ' ')
             
-            # Asegurar que solo caracteres imprimibles o saltos de línea/tabs se pasen a FPDF
-            # Esto es crucial para evitar errores FPDFException "character not in font"
             printable_text = "".join(c for c in clean_text if c.isprintable() or c in ('\n', '\r', '\t'))
 
             paragraphs = printable_text.split('\n')
             for para_idx, para in enumerate(paragraphs):
                 if para.strip():
                     try:
-                        pdf.multi_cell(0, 7, para) # Altura de línea 7
-                        pdf.ln(2) # Espacio pequeño después de párrafo
+                        pdf.multi_cell(0, 7, para)
+                        pdf.ln(2) 
                     except FPDFException as e_font_char:
-                        # Si un carácter específico causa problemas incluso después de la limpieza general:
-                        problem_char_hex = [hex(ord(c)) for c in para if not (c.isprintable() or c in ('\n', '\r', '\t'))]
-                        print(f"Advertencia: Carácter no soportado en PDF en párrafo {para_idx+1} (font: {body_font_family}). Caracteres problemáticos (hex): {problem_char_hex}. Párrafo omitido/reemplazado.")
-                        # Opción 1: Omitir párrafo problemático
-                        # Opción 2: Intentar reemplazar caracteres no soportados y reintentar (más complejo)
-                        # Opción 3: Escribir un placeholder
+                        problem_chars_hex = [hex(ord(c)) for c in para if not (c.isprintable() or c in ('\n','\r','\t')) and ord(c) > 127]
+                        print(f"Advertencia: Carácter no soportado en PDF en párrafo {para_idx+1} (fuente: {pdf.font_family}). Problemáticos (hex): {problem_chars_hex}. Párrafo reemplazado.")
                         try:
-                            pdf.set_font('Arial', '', 11) # Fallback a Arial para el placeholder
-                            pdf.multi_cell(0, 7, "[Párrafo con caracteres no soportados por la fuente seleccionada]")
+                            current_body_font = pdf.font_family
+                            current_body_style = pdf.font_style
+                            pdf.set_font('Arial', '', 11) 
+                            pdf.multi_cell(0, 7, "[Párrafo con caracteres no soportados por la fuente. Contenido original en TXT si se generó.]")
                             pdf.ln(2)
-                            pdf.set_font(body_font_family, body_font_style, 11) # Volver a la fuente del cuerpo
-                        except: # Si incluso el placeholder falla
-                             pass # Simplemente omitir
+                            pdf.set_font(current_body_font, current_body_style, 11) 
+                        except: pass
                 else:
-                    pdf.ln(5) # Espacio para líneas vacías (simulando párrafos separados)
-
+                    pdf.ln(5) 
 
             with tempfile.NamedTemporaryFile(delete=False, mode='wb', suffix='.pdf') as tmp_file:
                 pdf_output_bytes = pdf.output(dest='S') 
                 tmp_file.write(pdf_output_bytes)
                 filepath = tmp_file.name
             return {'status': 'success', 'file': filepath, 'url': url}
-        except FPDFException as e_fpdf_text: # Errores durante la escritura de texto en PDF
+        except FPDFException as e_fpdf_text:
             import traceback
-            tb_str = traceback.format_exc()
-            error_message = f"Error de FPDF al generar PDF de texto: {str(e_fpdf_text)}\nDetalles: {tb_str}"
-            if len(error_message) > 500: error_message = error_message[:497] + "..."
-            return {'status': 'error', 'message': error_message, 'url': url}
-        except Exception as e: # Otros errores generales
+            return {'status': 'error', 'message': f"Error FPDF generando PDF de texto: {str(e_fpdf_text)}\n{traceback.format_exc()[:300]}", 'url': url}
+        except Exception as e:
             import traceback
-            tb_str = traceback.format_exc()
-            error_message = f"Error general al generar PDF de texto: {str(e)}\nDetalles: {tb_str}"
-            if len(error_message) > 500: error_message = error_message[:497] + "..."
-            return {'status': 'error', 'message': error_message, 'url': url}
+            return {'status': 'error', 'message': f"Error general generando PDF de texto: {str(e)}\n{traceback.format_exc()[:300]}", 'url': url}