Add application file

app.py

@@ -1,12 +1,11 @@
-import gradio as gr
-import transformers
-from transformers import pipeline
 import PyPDF2
 import pdfplumber
 from pdfminer.high_level import extract_pages, extract_text
 from pdfminer.layout import LTTextContainer, LTChar, LTRect, LTFigure
 import re
 import torch
+import transformers
+from transformers import pipeline
 from datasets import load_dataset
 import soundfile as sf
 from IPython.display import Audio
@@ -15,89 +14,60 @@ from datasets import load_dataset
 import sentencepiece as spm
 import os
 import tempfile
+import gradio as gr
 
 
-
+#reporting the created functions for the part 1
 def text_extraction(element):
-    # Extracting the text from the in-line text element
     line_text = element.get_text()
 
-    # Find the formats of the text
-    # Initialize the list with all the formats that appeared in the line of text
     line_formats = []
     for text_line in element:
         if isinstance(text_line, LTTextContainer):
-            # Iterating through each character in the line of text
             for character in text_line:
                 if isinstance(character, LTChar):
-                    # Append the font name of the character
                     line_formats.append(character.fontname)
-                    # Append the font size of the character
                     line_formats.append(character.size)
-    # Find the unique font sizes and names in the line
     format_per_line = list(set(line_formats))
 
-    # Return a tuple with the text in each line along with its format
     return (line_text, format_per_line)
 
 def read_pdf(pdf_pathy):
-  # create a PDF file object
   pdfFileObj = open(pdf_pathy, 'rb')
-  # create a PDF reader object
   pdfReaded = PyPDF2.PdfReader(pdfFileObj)
 
-  # Create the dictionary to extract text from each image
   text_per_pagy = {}
-  # We extract the pages from the PDF
   for pagenum, page in enumerate(extract_pages(pdf_pathy)):
       print("Elaborating Page_" +str(pagenum))
-      # Initialize the variables needed for the text extraction from the page
       pageObj = pdfReaded.pages[pagenum]
       page_text = []
       line_format = []
       page_content = []
 
-      # Open the pdf file
       pdf = pdfplumber.open(pdf_pathy)
 
-
-      # Find all the elements
       page_elements = [(element.y1, element) for element in page._objs]
-      # Sort all the elements as they appear in the page
       page_elements.sort(key=lambda a: a[0], reverse=True)
 
-      # Find the elements that composed a page
       for i,component in enumerate(page_elements):
-          # Extract the position of the top side of the element in the PDF
           pos= component[0]
-          # Extract the element of the page layout
           element = component[1]
 
-          # Check if the element is a text element
           if isinstance(element, LTTextContainer):
-              # Check if the text appeared in a table
-                  # Use the function to extract the text and format for each text element
                   (line_text, format_per_line) = text_extraction(element)
-                  # Append the text of each line to the page text
                   page_text.append(line_text)
-                  # Append the format for each line containing text
                   line_format.append(format_per_line)
                   page_content.append(line_text)
           
 
-      # Create the key of the dictionary
       dctkey = 'Page_'+str(pagenum)
-      # Add the list of list as the value of the page key
       text_per_pagy[dctkey]= [page_text, line_format, page_content]
 
-  # Closing the pdf file object
   pdfFileObj.close()
 
 
   return text_per_pagy
 
-#performing a cleaning of the contents
-import re
 
 def clean_text(text):
     # remove extra spaces
@@ -109,20 +79,14 @@ def clean_text(text):
 def extract_abstract(text_per_pagy):
     abstract_text = ""
     
-    #iterate through each page in the extracted text dictionary
     for page_num, page_text in text_per_pagy.items():
         if page_text:
-           # Replace hyphens used for line breaks
             page_text = page_text.replace("- ", "")
            
-            # Looking for the start of the abstract
             start_index = page_text.find("Abstract")
             if start_index != -1:
-                # Adjust the start index to exclude the word "Abstract" itself
-                # The length of "Abstract" is 8 characters; we also add 1 to skip the space after it
                 start_index += len("Abstract") + 1
 
-                # Searching the possible end markers of the abstract
                 end_markers = ["Introduction", "Summary", "Overview", "Background"]
                 end_index = -1
 
@@ -132,36 +96,33 @@ def extract_abstract(text_per_pagy):
                         end_index = temp_index
                         break
 
-                # If no end marker found, take entire text after "Abstract"
                 if end_index == -1:
                     end_index = len(page_text)
 
-                # Extract the abstract text
                 abstract = page_text[start_index:end_index].strip()
 
-                # Add the abstract to the complete text
                 abstract_text += " " + abstract
 
                 break
 
     return abstract_text
 
-
+#let's define a main function that gets the uploaded file (pdf) to do the job
 def main_function(uploaded_filepath):
-    #a control to see if there is a file uploaded
+    #put a control to see if there is a file uploaded
     if uploaded_filepath is None:
         return "No file loaded", None
 
-    #read and process the file
+    #read and process the file according to read_pdf
     text_per_pagy = read_pdf(uploaded_filepath)
 
-    #cleaning the text and getting the abstract
+    #cleaning the text and getting the abstract using the 2 other functions
     for key, value in text_per_pagy.items():
         cleaned_text = clean_text(' '.join(value[0]))
         text_per_pagy[key] = cleaned_text
     abstract_text = extract_abstract(text_per_pagy)
 
-    #abstract summary
+    #abstract the summary with my pipeline and model, deciding the length
     summarizer = pipeline("summarization", model="pszemraj/long-t5-tglobal-base-sci-simplify")
     summary = summarizer(abstract_text, max_length=50, min_length=30, do_sample=False)[0]['summary_text']
 
@@ -171,20 +132,20 @@ def main_function(uploaded_filepath):
     speaker_embedding = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
     speech = synthesiser(summary, forward_params={"speaker_embeddings": speaker_embedding})
 
-    #saving the audio in a temp file
+    #saving the audio in a temporary file
     audio_file_path = "summary.wav"
     sf.write(audio_file_path, speech["audio"], samplerate=speech["sampling_rate"])
 
     #the function returns the 2 pieces we need
     return summary, audio_file_path
 
-
+#let's communicate with gradio what it has to put in
 iface = gr.Interface(
     fn=main_function,
-    inputs=gr.File(type="filepath"),  # Cambiato da "pdf" a "file"
+    inputs=gr.File(type="filepath"),  
     outputs=[gr.Textbox(label="Summary Text"), gr.Audio(label="Summary Audio", type="filepath")]
 )
 
-# Avvia l'app
+#launching the app
 if __name__ == "__main__":
     iface.launch()