Update app.py

app.py

@@ -264,75 +264,82 @@ class PaperDownloader:
                 logger.debug(f"Crossref error for {doi}: {e}")
             return None
 
-    async def download_with_retry_async(self, doi, max_retries=5, initial_delay=2):
-        pdf_content = None
-        retries = 0
-        delay = initial_delay
+    async def download_with_retry_async(self, doi, max_retries=3):
+        """
+        Intenta descargar un paper con múltiples estrategias y un número limitado de reintentos.
+        
+        Args:
+            doi (str): DOI del paper a descargar
+            max_retries (int): Número máximo de reintentos
+        
+        Returns:
+            bytes or None: Contenido del PDF o None si no se puede descargar
+        """
+        if not doi:
+            logger.warning("DOI no proporcionado")
+            return None
+    
+        # Estrategias de descarga en orden de preferencia
+        download_strategies = [
+            self.download_paper_direct_doi_async,
+            self.download_paper_scihub_async,
+            self.download_paper_libgen_async,
+            self.download_paper_google_scholar_async,
+            self.download_paper_crossref_async
+        ]
     
         async with aiohttp.ClientSession() as session:
-            while retries < max_retries and not pdf_content:
-                try:
-                    logger.info(f"Attempt {retries + 1} to download DOI: {doi}")
-                    
-                    # Strategies in order
-                    download_strategies = [
-                        self.download_paper_direct_doi_async,
-                        self.download_paper_scihub_async,
-                        self.download_paper_libgen_async,
-                        self.download_paper_google_scholar_async,
-                        self.download_paper_crossref_async
-                    ]
-                    
-                    for strategy in download_strategies:
+            for retry in range(max_retries):
+                logger.info(f"Intento de descarga {retry + 1} para DOI: {doi}")
+                
+                # Probar cada estrategia de descarga
+                for strategy in download_strategies:
+                    try:
                         pdf_content = await strategy(session, doi)
                         if pdf_content:
-                            logger.info(f"Successfully downloaded {doi} using {strategy.__name__}")
+                            logger.info(f"Descarga exitosa de {doi} usando {strategy.__name__}")
                             return pdf_content
-                    
-                    # If no strategy worked, skip this iteration
-                    retries += 1
-                    logger.warning(f"No successful strategy for DOI: {doi}. Retry {retries}")
-                    await asyncio.sleep(delay)
-                    delay *= 2  # Exponential backoff
+                    except Exception as e:
+                        logger.debug(f"Error en estrategia {strategy.__name__} para {doi}: {e}")
+                
+                # Si ninguna estrategia funcionó, esperar un poco antes de reintentar
+                await asyncio.sleep(1)  # Pequeña pausa entre reintentos
     
-                except Exception as e:
-                    logger.error(f"Unexpected error in download attempt {retries + 1} for DOI {doi}: {e}")
-                    retries += 1
-                    await asyncio.sleep(delay)
-                    delay *= 2
-            
-            logger.warning(f"FINAL FAILURE: Could not download DOI {doi} after {max_retries} attempts")
+            # Si se agotan todos los reintentos
+            logger.warning(f"FALLO FINAL: No se pudo descargar DOI {doi} después de {max_retries} intentos")
             return None
     
     async def download_single_doi_async(self, doi, progress_callback):
-            """Downloads a single paper using a DOI, and updates the given progress_callback"""
-            if not doi:
-                return None, "Error: DOI not provided", "Error: DOI not provided"
+        """Descargar un único DOI con retroalimentación de progreso"""
+        if not doi:
+            return None, "Error: DOI no proporcionado", "Error: DOI no proporcionado"
     
-            try:
-                pdf_content = await self.download_with_retry_async(doi)
+        try:
+            pdf_content = await self.download_with_retry_async(doi)
     
-                if pdf_content:
-                    if doi is None:
-                        return None, "Error: DOI not provided", "Error: DOI not provided"
-                    filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
-                    filepath = os.path.join(self.output_dir, filename)
-
-                    loop = asyncio.get_running_loop()
-                    await loop.run_in_executor(self.executor, lambda: open(filepath, 'wb').write(pdf_content))
-                    
-                    logger.info(f"Successfully downloaded: {filename}")
-                    progress_callback(f"Successfully downloaded: <a href='https://doi.org/{doi}'>{doi}</a>")
-                    return filepath, f'<a href="https://doi.org/{doi}">{doi}</a>', ""
-                else:
-                    logger.warning(f"Could not download: {doi}")
-                    progress_callback(f"Could not download:  <a href='https://doi.org/{doi}'>{doi}</a>")
-                    return None, f"Could not download {doi}", f'<a href="https://doi.org/{doi}">{doi}</a>'
+            if pdf_content:
+                filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
+                filepath = os.path.join(self.output_dir, filename)
     
-            except Exception as e:
-                logger.error(f"Error processing {doi}: {e}")
-                progress_callback(f"Error processing {doi}:  <a href='https://doi.org/{doi}'>{doi}</a> {e}")
-                return None, f"Error processing {doi}: {e}", f"Error processing {doi}: {e}"
+                # Escribir contenido del PDF
+                loop = asyncio.get_running_loop()
+                await loop.run_in_executor(
+                    self.executor, 
+                    lambda: open(filepath, 'wb').write(pdf_content)
+                )
+                
+                logger.info(f"Descarga exitosa: {filename}")
+                progress_callback(f"Descargado exitosamente: <a href='https://doi.org/{doi}'>{doi}</a>")
+                return filepath, f'<a href="https://doi.org/{doi}">{doi}</a>', ""
+            else:
+                logger.warning(f"No se pudo descargar: {doi}")
+                progress_callback(f"No se pudo descargar: <a href='https://doi.org/{doi}'>{doi}</a>")
+                return None, f"No se pudo descargar {doi}", f'<a href="https://doi.org/{doi}">{doi}</a>'
+    
+        except Exception as e:
+            logger.error(f"Error procesando {doi}: {e}")
+            progress_callback(f"Error procesando {doi}: <a href='https://doi.org/{doi}'>{doi}</a> {e}")
+            return None, f"Error procesando {doi}: {e}", f"Error procesando {doi}: {e}"
     
     async def download_multiple_dois_async(self, dois_text, progress_callback):
         # Validar entrada