Update app.py

app.py

@@ -265,27 +265,16 @@ class PaperDownloader:
             return None
 
     async def download_with_retry_async(self, doi, max_retries=5, initial_delay=2):
-        """Downloads a paper using multiple strategies with exponential backoff and async requests"""
         pdf_content = None
         retries = 0
         delay = initial_delay
     
-        # Additional Sci-Hub and alternative sources
-        additional_sources = [
-            'https://sci-hub.ren/',
-            'https://sci-hub.se/',
-            'https://sci-hub.mksa.top/',
-            'https://sci-hub.ru/',
-            'https://sci-hub.st/',
-            'https://libgen.rs/scimag/'
-        ]
-    
         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}")
                     
-                    # Try primary sources
+                    # Strategies in order
                     download_strategies = [
                         self.download_paper_direct_doi_async,
                         self.download_paper_scihub_async,
@@ -300,47 +289,20 @@ class PaperDownloader:
                             logger.info(f"Successfully downloaded {doi} using {strategy.__name__}")
                             return pdf_content
                     
-                    # If not found, try additional sources
-                    if not pdf_content and retries > 1:
-                        for source in additional_sources:
-                            try:
-                                scihub_url = f"{source}{self.clean_doi(doi)}"
-                                logger.info(f"Trying alternative source: {scihub_url}")
-                                
-                                text, headers = await self.fetch_with_headers(session, scihub_url, timeout=15)
-                                if text:
-                                    # Extract potential PDF links
-                                    pdf_patterns = [
-                                        r'(https?://[^\s<>"]+?\.pdf)',
-                                        r'(https?://[^\s<>"]+?download/[^\s<>"]+)',
-                                        r'(https?://[^\s<>"]+?\/pdf\/[^\s<>"]+)',
-                                    ]
-                                    pdf_urls = []
-                                    for pattern in pdf_patterns:
-                                        pdf_urls.extend(re.findall(pattern, text))
-                                    
-                                    # Try downloading from found URLs
-                                    for pdf_url in pdf_urls:
-                                        pdf_content = await self.fetch_pdf_content(session, pdf_url)
-                                        if pdf_content:
-                                            logger.info(f"Found PDF from alternative source: {pdf_url}")
-                                            return pdf_content
-                            except Exception as e:
-                                logger.debug(f"Error with alternative source {source}: {e}")
+                    # 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.error(f"Unexpected error in download attempt {retries + 1} for DOI {doi}: {e}")
-    
-                # Prepare for next retry
-                if not pdf_content:
                     retries += 1
-                    logger.warning(f"Retry attempt {retries} for DOI: {doi} after {delay} seconds")
                     await asyncio.sleep(delay)
-                    delay *= 2  # Exponential backoff
-        
-        # Log final failure
-        logger.warning(f"FINAL FAILURE: Could not download DOI {doi} after {max_retries} attempts")
-        return None
+                    delay *= 2
+            
+            logger.warning(f"FINAL FAILURE: Could not download DOI {doi} after {max_retries} attempts")
+            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"""
@@ -373,60 +335,88 @@ class PaperDownloader:
                 return None, f"Error processing {doi}: {e}", f"Error processing {doi}: {e}"
     
     async def download_multiple_dois_async(self, dois_text, progress_callback):
+        # Validar entrada
         if not dois_text:
             return None, "Error: No DOIs provided", "Error: No DOIs provided"
     
-        # Sanitize and filter DOIs
-        dois = [doi.strip() for doi in dois_text.split('\n') if doi.strip()]
+        # Sanitizar y filtrar DOIs
+        # Eliminar líneas vacías, espacios en blanco, y DOIs duplicados
+        dois = list(set([doi.strip() for doi in dois_text.split('\n') if doi.strip()]))
+        
+        # Validar lista de DOIs
         if not dois:
             return None, "Error: No valid DOIs provided", "Error: No valid DOIs provided"
     
-        downloaded_files = []
-        failed_dois = []
-        downloaded_links = []
-       
-        # Use asyncio.gather to process all DOIs concurrently
+        # Listas para rastrear resultados
+        downloaded_files = []      # Rutas de archivos descargados
+        failed_dois = []           # DOIs que no se pudieron descargar
+        downloaded_links = []      # Links de DOIs descargados
+    
+        # Generar tareas de descarga concurrentes
         download_tasks = []
         for doi in dois:
             task = self.download_single_doi_async(doi, progress_callback)
             download_tasks.append(task)
         
-        # Wait for all downloads to complete
+        # Ejecutar todas las descargas concurrentemente
         results = await asyncio.gather(*download_tasks, return_exceptions=True)
         
+        # Procesar resultados de cada DOI
         for i, result in enumerate(results):
             doi = dois[i]
             
-            # Handle different result types
+            # Manejar diferentes tipos de resultados
             if isinstance(result, Exception):
-                # Unexpected error
-                failed_dois.append(f'<a href="https://doi.org/{doi}">{doi}</a> - Unexpected error: {str(result)}')
+                # Excepción inesperada
+                error_msg = f"Unexpected error: {str(result)}"
+                logger.error(f"Error downloading {doi}: {error_msg}")
+                failed_dois.append(f'<a href="https://doi.org/{doi}">{doi}</a> - {error_msg}')
+            
             elif result[0] is None:
-                # Download failed
-                failed_dois.append(f'<a href="https://doi.org/{doi}">{doi}</a> - {result[1]}')
+                # Descarga fallida (resultado de download_single_doi_async)
+                error_msg = result[1]
+                logger.warning(f"Failed to download {doi}: {error_msg}")
+                failed_dois.append(f'<a href="https://doi.org/{doi}">{doi}</a> - {error_msg}')
+            
             else:
-                # Successful download
+                # Descarga exitosa
                 filepath = result[0]
                 
-                # Create unique filename for zip
+                # Generar nombre de archivo único
                 filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
                 filepath_unique = os.path.join(self.output_dir, filename)
                 
-                # Rename and add to downloaded files
-                os.rename(filepath, filepath_unique)
-                downloaded_files.append(filepath_unique)
-                downloaded_links.append(f'<a href="https://doi.org/{doi}">{doi}</a>')
-        
-        # Create zip if any files were downloaded
+                try:
+                    # Renombrar archivo
+                    os.rename(filepath, filepath_unique)
+                    
+                    # Añadir a lista de archivos descargados
+                    downloaded_files.append(filepath_unique)
+                    downloaded_links.append(f'<a href="https://doi.org/{doi}">{doi}</a>')
+                
+                except Exception as rename_error:
+                    logger.error(f"Error renaming file for {doi}: {rename_error}")
+                    failed_dois.append(f'<a href="https://doi.org/{doi}">{doi}</a> - Error saving file')
+    
+        # Crear archivo ZIP si hay archivos descargados
+        zip_filename = None
         if downloaded_files:
             zip_filename = 'papers.zip'
             loop = asyncio.get_running_loop()
-            await loop.run_in_executor(self.executor, lambda: self.create_zip(zip_filename, downloaded_files))
+            
+            # Ejecutar creación de ZIP en un executor para no bloquear
+            await loop.run_in_executor(
+                self.executor, 
+                lambda: self.create_zip(zip_filename, downloaded_files)
+            )
             logger.info(f"ZIP file created: {zip_filename}")
-        
-        return (zip_filename if downloaded_files else None, 
-                "\n".join(downloaded_links), 
-                "\n".join(failed_dois))
+    
+        # Devolver resultados
+        return (
+            zip_filename if downloaded_files else None,  # Archivo ZIP o None
+            "\n".join(downloaded_links),                # DOIs descargados 
+            "\n".join(failed_dois)                      # DOIs fallidos
+        )
 
     async def process_bibtex_async(self, bib_file, progress_callback):
             """Process BibTeX file and download papers with multiple strategies and reports UI updates using a callback"""