Update app.py

app.py

@@ -12,7 +12,7 @@ from bs4 import BeautifulSoup
 import io
 import asyncio
 import aiohttp
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, CancelledError
 
 # Configure logging
 logging.basicConfig(level=logging.INFO,
@@ -42,6 +42,7 @@ class PaperDownloader:
             'Accept-Language': 'en-US,en;q=0.9',
         }
         self.executor = ThreadPoolExecutor(max_workers=4)
+        self.download_task = None # Added attribute
 
     def clean_doi(self, doi):
         """Clean and encode DOI for URL"""
@@ -67,11 +68,12 @@ class PaperDownloader:
         retry_count = 0
 
         while redirect_count <= max_redirects:
+          
             try:
                 while retry_count <= max_retries:
                     try:
-                         logger.debug(f"Fetching PDF from {current_url} - Retry {retry_count + 1}")#ADDED
-                         async with session.get(current_url, headers=self.headers, timeout=10, allow_redirects=False) as response:
+                        logger.debug(f"Fetching PDF from {current_url} - Retry {retry_count + 1}")#ADDED
+                        async with session.get(current_url, headers=self.headers, timeout=10, allow_redirects=False) as response:
                             if response.status in [301, 302, 307, 308]:
                                 current_url = response.headers['Location']
                                 redirect_count += 1
@@ -90,13 +92,18 @@ class PaperDownloader:
                          logger.debug(f"Error getting PDF, retrying ({retry_count}/{max_retries}) from {current_url}: {e}")
                          retry_count += 1
                          await asyncio.sleep(retry_delay)
-
+                         
                 retry_count = 0  # Reset the retry count, in case there's a next redirect attempt
+            except CancelledError:
+                logger.info(f"Fetch PDF cancelled from: {url}")
+                return None
 
             except Exception as e:
                 logger.debug(f"Error getting PDF from {current_url}: {e}")
                 return None
 
+            
+            
         logger.debug(f"Too many redirects or retries {url}, not following this link further")
         return None
         
@@ -139,19 +146,22 @@ class PaperDownloader:
             except Exception as e:
                 logger.debug(f"Error trying to get the PDF from {doi}: {e}")
                 return None
-        
+            
     async def download_paper_scihub_async(self, session, doi):
         """Improved method to download paper from Sci-Hub using async requests"""
         if not doi:
             logger.warning("DOI not provided")
             return None
-
+    
+        
         for base_url in self.download_sources:
+           
             try:
                 scihub_url = f"{base_url}{self.clean_doi(doi)}"
                 text, headers = await self.fetch_with_headers(session, scihub_url, timeout=15)
                 if not text:
                     continue
+                    
 
                 # Search for multiple PDF URL patterns
                 pdf_patterns = [
@@ -159,10 +169,12 @@ class PaperDownloader:
                     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, but iterate over ALL
                 for pdf_url in pdf_urls:
@@ -170,10 +182,11 @@ class PaperDownloader:
                     if pdf_content:
                         logger.debug(f"Found PDF from: {pdf_url}")
                         return pdf_content
-
+                    
             except Exception as e:
-                logger.debug(f"Error trying to download {doi} from {base_url}: {e}")
-    
+                 logger.debug(f"Error trying to download {doi} from {base_url}: {e}")
+
+        
         return None
 
     async def download_paper_libgen_async(self, session, doi):
@@ -300,223 +313,300 @@ class PaperDownloader:
                         if pdf_content:
                             logger.info(f"Descarga exitosa de {doi} usando {strategy.__name__}")
                             return pdf_content
+                    except CancelledError:
+                         logger.info(f"Download cancelled on strategy: {strategy.__name__} with DOI {doi}")
+                         return None # return here in order to stop retry
+
                     except Exception as e:
                         logger.debug(f"Error en estrategia {strategy.__name__} para {doi}: {e}") #ADDED
-                
+                    
+                    
                 # Si ninguna estrategia funcionó, esperar un poco antes de reintentar
                 await asyncio.sleep(1)  # Pequeña pausa entre reintentos
-    
+                
+                if retry == max_retries -1: #log all if it does not works on max retries.
+                      logger.warning(f"FALLO FINAL: No se pudo descargar DOI {doi} después de {max_retries} intentos")
+
+
             # 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):
+
+    def _download_single_doi(self, doi, progress_callback, cancel_event): # removed async keyword
             """Descargar un único DOI con retroalimentación de progreso"""
             if not doi:
-                return None, "Error: DOI no proporcionado", "Error: DOI no proporcionado", ""
+                progress_callback(None, "Error: DOI no proporcionado", "Error: DOI no proporcionado")
+                return None
             logger.info(f"Starting download process for DOI: {doi}")
+            
             try:
-                pdf_content = await self.download_with_retry_async(doi)
-                if pdf_content:
-                    logger.info(f"Downloaded PDF for DOI: {doi}")
-                    filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
-                    filepath = os.path.join(self.output_dir, filename)
-
-                    # 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"Saved PDF to file: {filepath}")
-                    await asyncio.sleep(0.1)  #force wait here
-                    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}")
-                    await asyncio.sleep(0.1)  #force wait here
-                    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>', ""
-
+                
+                async def call_async():# Added this in order to execute correctly on executor
+
+                   pdf_content = await self.download_with_retry_async(doi)
+                   if pdf_content:
+                        logger.info(f"Downloaded PDF for DOI: {doi}")
+                        filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
+                        filepath = os.path.join(self.output_dir, filename)
+
+                        # Escribir contenido del PDF
+                        
+                        open(filepath, 'wb').write(pdf_content)
+                       
+                        logger.info(f"Saved PDF to file: {filepath}")
+
+                        logger.info(f"Descarga exitosa: {filename}")
+                        
+                        progress_callback(filepath, f"Descargado exitosamente: <a href='https://doi.org/{doi}'>{doi}</a>", "")
+                        
+                        
+                   else:
+                        logger.warning(f"No se pudo descargar: {doi}")
+                        progress_callback(None, f"No se pudo descargar {doi}", f'<a href="https://doi.org/{doi}">{doi}</a>')
+            
+                asyncio.run(call_async()) #added the loop event here
+                
+            except CancelledError:
+               logger.info(f"Download Cancelled DOI: {doi}")
+               progress_callback(None, f"Download cancelled {doi}","Download Cancelled" )
+               
             except Exception as e:
-                logger.error(f"Error processing {doi}: {e}")
-                await asyncio.sleep(0.1) #force wait here
-                progress_callback(f"Error procesando {doi}: <a href='https://doi.org/{doi}'>{e}")
-                return None, f"Error procesando {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", ""
+               logger.error(f"Error processing {doi}: {e}")
+               progress_callback(None, f"Error processing {doi}: {e}", f"Error processing {doi}: {e}" )
+               
     
-        # 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", ""
-    
-        # Listas para rastrear resultados
-        downloaded_files = []      # Rutas de archivos descargados
-        failed_dois = []           # DOIs que no se pudieron descargar
-        downloaded_links = []      # Links de DOIs descargados
+    def download_multiple_dois(self, dois_text, progress_callback, cancel_event): #removed async here
+            """Download multiple DOIs"""
+             # Validar entrada
+            if not dois_text:
+                progress_callback(None, "Error: No DOIs provided", "Error: No DOIs provided",)
+                return None
+
+            # 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:
+                progress_callback(None, "Error: No valid DOIs provided", "Error: No valid DOIs provided")
+                return None
     
-        # Generar tareas de descarga concurrentes
-        download_tasks = []
-        for doi in dois:
-            task = self.download_single_doi_async(doi, progress_callback)
-            download_tasks.append(task)
-        
-        # 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]
+            # Listas para rastrear resultados
+            downloaded_files = []      # Rutas de archivos descargados
+            failed_dois = []           # DOIs que no se pudieron descargar
+            downloaded_links = []      # Links de DOIs descargados
+          
+
+            for doi in dois:
+                    self._download_single_doi(doi, lambda a,b,c: progress_callback(a,b,c, doi) , cancel_event )
+                    if cancel_event.is_set():
+                         logger.info("Downloads cancelled on multiple dois download")
+                         progress_callback(None,  "Downloads cancelled","Downloads cancelled") # early return on cancelled
+                         return None #break here when is cancelled
+
+                    result = self.results_dict.get(doi, (None,None,"")) # obtain from self.results
+
+                    # Manejar diferentes tipos de resultados
+                    if isinstance(result, Exception):
+                        # 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:
+                        # 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:
+                        # Descarga exitosa
+                        filepath = result[0]
+                        
+                        # Generar nombre de archivo único
+                        filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
+                        filepath_unique = os.path.join(self.output_dir, filename)
+                        
+                        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()
             
-            # Manejar diferentes tipos de resultados
-            if isinstance(result, Exception):
-                # 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}')
+                # Ejecutar creación de ZIP en un executor para no bloquear
+                loop.run_in_executor(
+                    self.executor, 
+                    lambda: self.create_zip(zip_filename, downloaded_files)
+                )
+                logger.info(f"ZIP file created: {zip_filename}")
+        
+
+            # Devolver resultados
+            progress_callback( zip_filename if downloaded_files else None, "\n".join(downloaded_links),"\n".join(failed_dois))
+            return
             
-            elif result[0] is None:
-                # 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}')
+    def process_bibtex(self, bib_file, progress_callback, cancel_event):# removed async here
+            """Process BibTeX file and download papers with multiple strategies and reports UI updates using a callback"""
+            # Read BibTeX file content from the uploaded object
+            try:
+                with open(bib_file.name, 'r', encoding='utf-8') as f:
+                    bib_content = f.read()
+            except Exception as e:
+                logger.error(f"Error reading uploaded file {bib_file.name}: {e}")
+                progress_callback(None, f"Error reading uploaded file {bib_file.name}: {e}", f"Error reading uploaded file {bib_file.name}: {e}" )
+                return None
+
+            # Parse BibTeX data
+            try:
+                bib_database = bibtexparser.loads(bib_content)
+            except Exception as e:
+                logger.error(f"Error parsing BibTeX data: {e}")
+                progress_callback(None,f"Error parsing BibTeX data: {e}", f"Error parsing BibTeX data: {e}")
+                return None
+
+            # Extract DOIs
+            dois = [entry.get('doi') for entry in bib_database.entries if entry.get('doi')]
+            logger.info(f"Found {len(dois)} DOIs to download")
+
+             # Result lists
+            downloaded_files = []
+            failed_dois = []
+            downloaded_links = []
+
+            for doi in dois:
+
+                 self._download_single_doi(doi,  lambda a,b,c: progress_callback(a,b,c, doi), cancel_event )
+                 if cancel_event.is_set():
+                       logger.info("Download Cancelled in bibtex mode")
+                       progress_callback(None, "Download Cancelled", "Download Cancelled")
+                       return None #cancel if requested
+                       
+                 result = self.results_dict.get(doi, (None,None,"")) # obtain from self.results
             
-            else:
-                # Descarga exitosa
-                filepath = result[0]
+                 if isinstance(result, Exception):
+                    # 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}')
                 
-                # Generar nombre de archivo único
-                filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
-                filepath_unique = os.path.join(self.output_dir, filename)
+                 elif result[0] is None:
+                    # 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}')
                 
-                try:
-                    # Renombrar archivo
-                    os.rename(filepath, filepath_unique)
+                 else:
+                    # Descarga exitosa
+                    filepath = result[0]
                     
-                    # Añadir a lista de archivos descargados
+                    # Unique filename for zip
+                    filename = f"{str(doi).replace('/', '_').replace('.', '_')}_{i}.pdf"
+                    filepath_unique = os.path.join(self.output_dir, filename)
+                    os.rename(filepath, filepath_unique)
                     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')
-        await asyncio.sleep(0.1)
-        # Crear archivo ZIP si hay archivos descargados
-        zip_filename = None
-        if downloaded_files:
-            zip_filename = 'papers.zip'
-            loop = asyncio.get_running_loop()
-            
-            # 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}")
-    
-        # 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"""
-        # Read BibTeX file content from the uploaded object
-        try:
-            with open(bib_file.name, 'r', encoding='utf-8') as f:
-                bib_content = f.read()
-        except Exception as e:
-            logger.error(f"Error reading uploaded file {bib_file.name}: {e}")
-            return None, f"Error reading uploaded file {bib_file.name}: {e}", f"Error reading uploaded file {bib_file.name}: {e}", ""
-    
-        # Parse BibTeX data
-        try:
-            bib_database = bibtexparser.loads(bib_content)
-        except Exception as e:
-            logger.error(f"Error parsing BibTeX data: {e}")
-            return None, f"Error parsing BibTeX data: {e}", f"Error parsing BibTeX data: {e}", ""
-    
-        # Extract DOIs
-        dois = [entry.get('doi') for entry in bib_database.entries if entry.get('doi')]
-        logger.info(f"Found {len(dois)} DOIs to download")
-    
-        # Result lists
-        downloaded_files = []
-        failed_dois = []
-        downloaded_links = []
-    
-        tasks = [self.download_single_doi_async(doi, progress_callback) for doi in dois]
-        results = await asyncio.gather(*tasks)
-
-        for i, (filepath, success_message, fail_message,_) in enumerate(results):
-            if filepath:
-                # Unique filename for zip
-                filename = f"{str(dois[i]).replace('/', '_').replace('.', '_')}_{i}.pdf"
-                filepath_unique = os.path.join(self.output_dir, filename)
-                os.rename(filepath, filepath_unique)
-                downloaded_files.append(filepath_unique)
-                downloaded_links.append(f'<a href="https://doi.org/{dois[i]}">{dois[i]}</a>')
-            else:
-                failed_dois.append(f'<a href="https://doi.org/{dois[i]}">{dois[i]}</a>')
-        await asyncio.sleep(0.1) #force wait
-        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))
-            logger.info(f"ZIP file created: {zip_filename}")
-    
-        return zip_filename, "\n".join(downloaded_links), "\n".join(failed_dois), ""
+
+
+            if downloaded_files:
+                zip_filename = 'papers.zip'
+                loop = asyncio.get_running_loop()
+                loop.run_in_executor(self.executor, lambda:  self.create_zip(zip_filename,downloaded_files))
+                logger.info(f"ZIP file created: {zip_filename}")
     
+            progress_callback(zip_filename, "\n".join(downloaded_links), "\n".join(failed_dois)) #after process finishes
+            return
+
     def create_zip(self, zip_filename, files):
         """Crea un archivo zip con los pdfs descargados"""
         with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zf:
             for file in files:
                 zf.write(file, os.path.basename(file))
+    def cancel_download(self):
+           if self.download_task:
+                self.cancel_event.set()
+                # Cancel the download task if it exists and it is cancelable
+                
+                self.download_task.cancel()
 
 def create_gradio_interface():
     """Create Gradio interface for Paper Downloader"""
     downloader = PaperDownloader()
 
-    def update_progress(message, log_message=""):
-      return gr.HTML(value=f"{message}"), gr.HTML(value=f"<pre>{log_message}</pre>")
+    downloader.results_dict = {}  #shared results dict, since it runs on different threads
 
-    async def download_papers(bib_file, doi_input, dois_input):
+    def update_progress( message="", logs=""):
+      return  gr.Textbox.update(value=f"{message}"),gr.Textbox.update(value=f"<pre>{logs}</pre>")
+    
 
-        def custom_progress_callback(message):
-            logger.info(f"Callback message: {message}")
+    def download_papers(bib_file, doi_input, dois_input):
+            cancel_event = asyncio.Event() # Create cancellation event for every submission.
+            downloader.cancel_event = cancel_event # store the event so that it is available to stop the process
             
-            return update_progress(message)
-    
-        if bib_file:
-            # Check file type
-            if not bib_file.name.lower().endswith('.bib'):
-                return None, "Error: Please upload a .bib file", "Error: Please upload a .bib file", "", None
+            def custom_progress_callback(filepath, message, fail_message, doi=None): #new callback to send to the execution function
+
+                    logger.info(f"Callback message: {message}") # log each callback msg
+                   
+                    #store data for single or multiple mode on download_papers execution.
+                    if doi:
+                          downloader.results_dict[doi] = (filepath, message,fail_message)
+
+                    updates = update_progress(message)
+
+                    return updates
+                
+
+            if bib_file:
+                # Check file type
+                 if not bib_file.name.lower().endswith('.bib'):
+                    return None, "Error: Please upload a .bib file", "Error: Please upload a .bib file", None
+                    
+                downloader.download_task = downloader.executor.submit(
+                        downloader.process_bibtex, 
+                         bib_file,
+                        lambda a,b,c:  update_progress(a,f"{b}<br>{c}"), #convert for ui output, the return data will contain the HTML
+                        cancel_event # Added cancelllation event.
+                )
+              
+                return None,"","",None
+             
+            elif doi_input:
+                
+                downloader.download_task = downloader.executor.submit( #changed async execution method
+                         downloader._download_single_doi, 
+                          doi_input, 
+                           lambda a,b,c: update_progress(a,f"{b}<br>{c}")  , #callback function, format output and send html info, removed lambda from executor calls
+                           cancel_event  # Add cancellation event.
+                      )
+                
+                return  None, "","", None
             
-            zip_path, downloaded_dois, failed_dois, _ = await downloader.process_bibtex_async(bib_file, custom_progress_callback)
-            await asyncio.sleep(0.1) #force wait
-            return zip_path, downloaded_dois, failed_dois, "", None
-        elif doi_input:
-            filepath, message, failed_doi, _ = await downloader.download_single_doi_async(doi_input,custom_progress_callback)
-            await asyncio.sleep(0.1) #force wait
-            return None, message, failed_doi, "", filepath
-        elif dois_input:
-            zip_path, downloaded_dois, failed_dois, _ = await downloader.download_multiple_dois_async(dois_input, custom_progress_callback)
-            await asyncio.sleep(0.1) #force wait
-            return zip_path, downloaded_dois, failed_dois, "", None
-        else:
-            return None, "Please provide a .bib file, a single DOI, or a list of DOIs", "Please provide a .bib file, a single DOI, or a list of DOIs", "", None
-    
+            elif dois_input:
+                downloader.download_task = downloader.executor.submit( #changed async execution method
+                        downloader.download_multiple_dois,
+                         dois_input,
+                       lambda a,b,c: update_progress(a,f"{b}<br>{c}") ,#callback function
+                        cancel_event #Add cancellation event.
+                  )
+                 
+                return  None, "","", None
+
+            else:
+               return None, "Please provide a .bib file, a single DOI, or a list of DOIs", "Please provide a .bib file, a single DOI, or a list of DOIs","", None
+
     
 
     # Gradio Interface
@@ -525,37 +615,23 @@ def create_gradio_interface():
         inputs=[
             gr.File(file_types=['.bib'], label="Upload BibTeX File"),
             gr.Textbox(label="Enter Single DOI", placeholder="10.xxxx/xxxx"),
-            gr.Textbox(label="Enter Multiple DOIs (one per line)", placeholder="10.xxxx/xxxx\n10.yyyy/yyyy\n...")
+            gr.Textbox(label="Enter Multiple DOIs (one per line)", placeholder="10.xxxx/xxxx\n10.yyyy/yyyy\n..."),
+           
         ],
         outputs=[
             gr.File(label="Download Papers (ZIP) or Single PDF"),
-            gr.HTML(label="""
-                <div style='padding-bottom: 5px; font-weight: bold;'>
-                    Found DOIs
-                </div>
-                <div style='border: 1px solid #ddd; padding: 5px; border-radius: 5px;'>
-                    <div id="downloaded-dois"></div>
-                </div>
+            gr.Textbox(label="""
+                Found DOIs
             """),
-            gr.HTML(label="""
-                <div style='padding-bottom: 5px; font-weight: bold;'>
-                    Missed DOIs
-                </div>
-                <div style='border: 1px solid #ddd; padding: 5px; border-radius: 5px;'>
-                    <div id="failed-dois"></div>
-                </div>
+             gr.Textbox(label="""
+                Missed DOIs
             """),
-              gr.HTML(label="""
-            <div style='padding-bottom: 5px; font-weight: bold;'>
-                Logs
-            </div>
-                <div style='border: 1px solid #ddd; padding: 5px; border-radius: 5px; max-height: 150px; overflow-y: auto;white-space: pre-line;'>
-                   
-                </div>
-        
-            """,),
+              gr.Textbox(label="""
+            Logs
+            """, lines = 10),
             gr.File(label="Downloaded Single PDF")
         ],
+         
         title="🔬 Academic Paper Batch Downloader",
         description="Upload a BibTeX file or enter DOIs to download PDFs. We'll attempt to fetch PDFs from multiple sources like Sci-Hub, Libgen, Google Scholar and Crossref. You can use any of the three inputs at any moment.",
         theme="Hev832/Applio",
@@ -584,9 +660,24 @@ def create_gradio_interface():
                 
             }
         """,
+         
+        
         cache_examples=False,
     )
 
+    interface.load= """
+      () => {
+        
+        return []
+      }
+     """
+    # Adding clear button
+    with gr.Row():
+          
+           interface.stop_btn= gr.Button(value="Stop Downloads")
+           
+    interface.stop_btn.click(lambda: downloader.cancel_download(), outputs=None) #added function in object downloader
+    
     return interface
 
 def main():