| # import os | |
| # import pdfplumber | |
| # import re | |
| # import gradio as gr | |
| # from transformers import pipeline, AutoModelForQuestionAnswering, AutoTokenizer | |
| # from io import BytesIO | |
| # import torch | |
| # """ | |
| # Extract the text from a section of a PDF file between 'wanted_section' and 'next_section'. | |
| # Parameters: | |
| # - path (str): The file path to the PDF file. | |
| # - wanted_section (str): The section to start extracting text from. | |
| # - next_section (str): The section to stop extracting text at. | |
| # Returns: | |
| # - text (str): The extracted text from the specified section range. | |
| # """ | |
| # def get_section(path, wanted_section, next_section): | |
| # print(wanted_section) | |
| # # Open the PDF file | |
| # doc = pdfplumber.open(BytesIO(path)) | |
| # start_page = [] | |
| # end_page = [] | |
| # # Find the all the pages for the specified sections | |
| # for page in range(len(doc.pages)): | |
| # if len(doc.pages[page].search(wanted_section, return_chars=False, case=False)) > 0: | |
| # start_page.append(page) | |
| # if len(doc.pages[page].search(next_section, return_chars=False, case=False)) > 0: | |
| # end_page.append(page) | |
| # # Extract the text between the start and end page of the wanted section | |
| # text = [] | |
| # for page_num in range(max(start_page), max(end_page)+1): | |
| # page = doc.pages[page_num] | |
| # text.append(page.extract_text()) | |
| # text = " ".join(text) | |
| # final_text = text.replace("\n", " ") | |
| # return final_text | |
| # def extract_between(big_string, start_string, end_string): | |
| # # Use a non-greedy match for content between start_string and end_string | |
| # pattern = re.escape(start_string) + '(.*?)' + re.escape(end_string) | |
| # match = re.search(pattern, big_string, re.DOTALL) | |
| # if match: | |
| # # Return the content without the start and end strings | |
| # return match.group(1) | |
| # else: | |
| # # Return None if the pattern is not found | |
| # return None | |
| # def format_section1(section1_text): | |
| # result_section1_dict = {} | |
| # result_section1_dict['TOPIC'] = extract_between(section1_text, "Sektor", "EZ-Programm") | |
| # result_section1_dict['PROGRAM'] = extract_between(section1_text, "Sektor", "EZ-Programm") | |
| # result_section1_dict['PROJECT DESCRIPTION'] = extract_between(section1_text, "EZ-Programmziel", "Datum der letzten BE") | |
| # result_section1_dict['PROJECT NAME'] = extract_between(section1_text, "Modul", "Modulziel") | |
| # result_section1_dict['OBJECTIVE'] = extract_between(section1_text, "Modulziel", "Berichtszeitraum") | |
| # result_section1_dict['PROGRESS'] = extract_between(section1_text, "Zielerreichung des Moduls", "Massnahme im Zeitplan") | |
| # result_section1_dict['STATUS'] = extract_between(section1_text, "Massnahme im Zeitplan", "Risikoeinschätzung") | |
| # result_section1_dict['RECOMMENDATIONS'] = extract_between(section1_text, "Vorschläge zur Modulanpas-", "Voraussichtliche") | |
| # return result_section1_dict | |
| # def answer_questions(text,language="de"): | |
| # # Initialize the zero-shot classification pipeline | |
| # model_name = "deepset/gelectra-large-germanquad" | |
| # model = AutoModelForQuestionAnswering.from_pretrained(model_name) | |
| # tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| # # Initialize the QA pipeline | |
| # qa_pipeline = pipeline("question-answering", model=model, tokenizer=tokenizer) | |
| # questions = [ | |
| # "Welches ist das Titel des Moduls?", | |
| # "Welches ist das Sektor oder das Kernthema?", | |
| # "Welches ist das Land?", | |
| # "Zu welchem Program oder EZ-Programm gehort das Projekt?" | |
| # #"Welche Durchführungsorganisation aus den 4 Varianten 'giz', 'kfw', 'ptb' und 'bgr' implementiert das Projekt?" | |
| # # "In dem Dokument was steht bei Sektor?", | |
| # # "In dem Dokument was steht von 'EZ-Programm' bis 'EZ-Programmziel'?", | |
| # # "In dem Dokument was steht bei EZ-Programmziel?", | |
| # # "In dem Dokument in dem Abschnitt '1. Kurzbeschreibung' was steht bei Modul?", | |
| # # "In dem Dokument was steht bei Zielerreichung des Moduls?", | |
| # # "In dem Dokument in dem Abschnitt '1. Kurzbeschreibung' was steht bei Maßnahme im Zeitplan?", | |
| # # "In dem Dokument was steht bei Vorschläge zur Modulanpassung?", | |
| # # "In dem Dokument in dem Abschnitt 'Anlage 1: Wirkungsmatrix des Moduls' was steht unter Laufzeit als erstes Datum?", | |
| # # "In dem Dokument in dem Abschnitt 'Anlage 1: Wirkungsmatrix des Moduls' was steht unter Laufzeit als zweites Datum?" | |
| # ] | |
| # # Iterate over each question and get answers | |
| # answers_dict = {} | |
| # for question in questions: | |
| # result = qa_pipeline(question=question, context=text) | |
| # # print(f"Question: {question}") | |
| # # print(f"Answer: {result['answer']}\n") | |
| # answers_dict[question] = result['answer'] | |
| # return answers_dict | |
| # def process_pdf(path): | |
| # results_dict = {} | |
| # results_dict["1. Kurzbeschreibung"] = \ | |
| # get_section(path, "1. Kurzbeschreibung", "2. Einordnung des Moduls") | |
| # answers = answer_questions(results_dict["1. Kurzbeschreibung"]) | |
| # return answers | |
| # def get_first_page_text(file_data): | |
| # doc = pdfplumber.open(BytesIO(file_data)) | |
| # if len(doc.pages): | |
| # return doc.pages[0].extract_text() | |
| # if __name__ == "__main__": | |
| # # Define the Gradio interface | |
| # # iface = gr.Interface(fn=process_pdf, | |
| # # demo = gr.Interface(fn=process_pdf, | |
| # # inputs=gr.File(type="binary", label="Upload PDF"), | |
| # # outputs=gr.Textbox(label="Extracted Text"), | |
| # # title="PDF Text Extractor", | |
| # # description="Upload a PDF file to extract.") | |
| # # demo.launch() | |
| # demo = gr.Interface(fn=process_pdf, | |
| # inputs=gr.File(type="pdf"), | |
| # outputs="text, | |
| # title="PDF Text Extractor", | |
| # description="Upload a PDF file to extract.") | |
| # demo.launch() | |
| import gradio as gr | |
| import pdfplumber | |
| from transformers import pipeline | |
| from io import BytesIO | |
| import re | |
| # Initialize the question-answering pipeline with a specific pre-trained model | |
| qa_pipeline = pipeline("question-answering", model="deepset/gelectra-large-germanquad") | |
| def extract_text_from_pdf(file_obj): | |
| """Extracts text from a PDF file.""" | |
| text = [] | |
| with pdfplumber.open(file_obj) as pdf: | |
| for page in pdf.pages: | |
| page_text = page.extract_text() | |
| if page_text: # Make sure there's text on the page | |
| text.append(page_text) | |
| return " ".join(text) | |
| def answer_questions(context): | |
| """Generates answers to predefined questions based on the provided context.""" | |
| questions = [ | |
| "Welches ist das Titel des Moduls?", | |
| "Welches ist das Sektor oder das Kernthema?", | |
| "Welches ist das Land?", | |
| "Zu welchem Program oder EZ-Programm gehört das Projekt?" | |
| ] | |
| answers = {q: qa_pipeline(question=q, context=context)['answer'] for q in questions} | |
| return answers | |
| def process_pdf(file): | |
| """Process a PDF file to extract text and then use the text to answer questions.""" | |
| # Read the PDF file from Gradio's file input, which is a temporary file path | |
| with file as file_path: | |
| text = extract_text_from_pdf(BytesIO(file_path.read())) | |
| results = answer_questions(text) | |
| return "\n".join(f"{q}: {a}" for q, a in results.items()) | |
| # Define the Gradio interface | |
| iface = gr.Interface( | |
| fn=process_pdf, | |
| inputs=gr.inputs.File(type="pdf", label="Upload your PDF file"), | |
| outputs=gr.outputs.Textbox(label="Extracted Information and Answers"), | |
| title="PDF Text Extractor and Question Answerer", | |
| description="Upload a PDF file to extract text and answer predefined questions based on the content." | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch() | |