Upload folder using huggingface_hub

src/gradio_app.py

@@ -4,7 +4,7 @@ import pypdfium2 as pdfium
 import gradio as gr
 
 from langchain.chat_models import ChatOpenAI
-from src.summarization import summarize_wrapper, parallel_summarization
+from src.summarization import summarize_wrapper
 from src.mailing import send_email
 
 # Function to render a specific page of a PDF file as an image
@@ -79,7 +79,6 @@ def run_summarization_model_gradio(
             summary_short = gr.Button("Kurze Zusammenfassung", interactive=False)
             summary_middle = gr.Button("Mittlere Zusammenfassung", interactive=False)
             summary_long = gr.Button("Lange Zusammenfassung", interactive=False)
-            summary_parallel = gr.Button("Parallele Zusammenfassung", interactive=False)
         with gr.Row().style(equal_height=True):
             with gr.Column(scale=1):
                 summary_output = gr.Textbox(label="Zusammenfassung", lines=9).style(
@@ -149,12 +148,6 @@ def run_summarization_model_gradio(
                 [send_email_button, gr.State(None), gr.State(None)],
                 queue=False,
             )
-        summary_parallel.click(
-            parallel_summarization,
-            [file_upload, gr.State(llm), gr.State(summarization_kwargs)],
-            [summary_output],
-            queue=False,
-        )
 
         # The clear button clears the dashboard
         clear.click(lambda: None, None, summary_output, queue=False).then(

src/prompts.py

@@ -150,112 +150,3 @@ Die Teile der Zusammenfassung mit Angabe der Seitenzahlen:
         ),
     },
 }
-
-
-def get_template_mp(name: str, headline: str, additional_text: str = ""):
-    base_multi = (
-        "Das folgende Urteil, das durch dreifache Anführungszeichen begrenzt ist, soll ausführlich zusammengefasst werden.\n"
-        "Dafür muss ein/e präzise/r <KEY> mittlerer Länge geschrieben werden.\n"
-        "\n"
-        "Text:\n"
-        "```{text}```\n"
-        "\n"
-        "Schreibe die <KEY> des Urteils. Falls dies nicht möglich ist antworte immer damit, dass die Informationen nicht vorhanden sind.\n"
-        "<ADDITIONAL_TEXT>\n"
-        'Als Überschrift muss "<HEAD_LINE>" angegeben werden. \n'
-        "Nach dem Paragraph muss die Quell-Seite angegeben werden z.B. (siehe Seite ?).\n"
-        "\n"
-        "<KEY>:\n"
-    )
-    return (
-        base_multi.replace("<KEY>", name)
-        .replace("<HEAD_LINE>", headline)
-        .replace("<ADDITIONAL_TEXT>", additional_text)
-    )
-
-
-prompts_parallel = {
-    "intro": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(name="Einleitung", headline="I. Einleitung"),
-    ),
-    "darstellung_des_rechtsproblems": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Darstellung des Rechtsproblems",
-            headline="Darstellung des Rechtsproblems",
-        ),
-    ),
-    "angaben_ueber_das_urteil": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Angaben über das Urteil",
-            headline="Angaben über das Urteil",
-            additional_text="Gib die folgenden Informationen an: Gericht, Datum, Aktenzeichen (AZ: ...), Fundstelle(n)",
-        ),
-    ),
-    "sachverhalt": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Sachverhalt",
-            headline="Sachverhalt (unter Rückgriff auf Instanzentscheidung)",
-            additional_text="Beziehe dich auf die Instanzentscheidung.",
-        ),
-    ),
-    "prozessgeschichte": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Prozessgeschichte", headline="3. Prozessgeschichte"
-        ),
-    ),
-    "rechtsproblem": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Rechtsproblem",
-            headline="Rechtsproblem",
-            additional_text="Das Problem des Falles ist genau herauszuarbeiten und im rechtlichen Kontext zu verankern.",
-        ),
-    ),
-    "loesung_des_gerichts": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Lösung des Gerichts", headline="Lösung des Gerichts"
-        ),
-    ),
-    "loesungsansaetze_zum_problem": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Lösungsansätze zum Problem",
-            headline="Lösungsansätze zum Problem",
-            additional_text="Knappe, aber möglichst vollständige Übersicht der vertretenen Ansichten.",
-        ),
-    ),
-    "analyse_und_einordnung_der_entscheidung": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Analyse und Einordnung der Entscheidung",
-            headline="Analyse und Einordnung der Entscheidung",
-        ),
-    ),
-    "bewertung_und_kritik_der_entscheidung": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Bewertung und Kritik der Entscheidung",
-            headline="Bewertung und Kritik der Entscheidung",
-        ),
-    ),
-    "eigener_loesungsvorschlag": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Eigener Lösungsvorschlag",
-            headline="Eigener Lösungsvorschlag",
-        ),
-    ),
-    "ausblick": PromptTemplate(
-        input_variables=["text"],
-        template=get_template_mp(
-            name="Ausblick",
-            headline="Ausblick",
-        ),
-    ),
-}

src/summarization.py

@@ -4,18 +4,15 @@ from langchain.chains.llm import LLMChain
 from langchain.chains.combine_documents.stuff import StuffDocumentsChain
 from langchain.chat_models import ChatOpenAI
 from langchain.docstore.document import Document
-from src.prompts import prompts, prompts_parallel
-import time
+from src.prompts import prompts
 from typing import Dict, List
-import asyncio
 
 
-def load_docs(file_path: str, with_pageinfo: bool = True) -> List[Document]:
+def load_docs(file_path: str) -> List[Document]:
     """Load a file and return the text.
 
     Args:
         file_path (str): Path to the pdf file. This can either be a local path or a tempfile.TemporaryFileWrapper_.
-        with_pageinfo (bool, optional): If True the page information is added to the document. Defaults to True.
 
     Raises:
         ValueError: If the file type is not supported.
@@ -36,15 +33,17 @@ def load_docs(file_path: str, with_pageinfo: bool = True) -> List[Document]:
     for doc in docs:
         doc.page_content = doc.page_content.replace("\n", " \n ")
         # if doc contains a page append it to the text
-        if with_pageinfo and hasattr(doc, "metadata"):
-            doc.page_content = f"(Quelle Seite: {doc.metadata.get('page')+1}) .".join(
-                doc.page_content.split(" .")
+        if hasattr(doc, "metadata"):
+            doc.page_content = (
+                f"Start {doc.metadata.get('page')+1}"
+                + doc.page_content
+                + f" \n Ende Seite {doc.metadata.get('page')+1}"
             )
 
     return docs
 
 
-def summarize_chain(
+def summarize(
     file_path: str, llm: ChatOpenAI, summarization_kwargs: Dict[str, str]
 ) -> str:
     """Summarize a pdf file. The summarization is done by the language model.
@@ -110,112 +109,6 @@ def summarize_wrapper(
     else:
         raise ValueError(f"Summarization type {summarization_type} is not supported.")
 
-    return summarize_chain(
+    return summarize(
         file_path=file.name, llm=llm[0], summarization_kwargs=summarization_kwargs
     )
-
-
-async def async_generate(
-    llm: ChatOpenAI, docs: List[Document], summarization_kwargs: dict, k: str
-) -> dict:
-    """Asyncronous summarization.
-
-    Args:
-        llm (ChatOpenAI): Language model to use for the summarization.
-        docs (List[Document]): List of documents.
-        summarization_kwargs (dict): Keyword arguments for the summarization.
-        k (str): Key for the summarization.
-
-    Returns:
-        dict: Dictionary with the summarization.
-    """
-    chain = load_summarize_chain(llm=llm, **summarization_kwargs)
-    resp = await chain.run(docs)
-    return {k: resp}
-
-
-async def generate_concurrently(file_path: str, llm: ChatOpenAI) -> List[dict]:
-    """Parallel summarization.
-
-    Args:
-        file_path (str): Path to the pdf file. This can either be a local path or a tempfile.TemporaryFileWrapper_.
-        llm (ChatOpenAI): Language model to use for the summarization.
-
-    Returns:
-        List: List of summarizations.
-    """
-
-    docs = load_docs(file_path=file_path)
-    summarization_kwargs = dict(
-        chain_type="stuff",
-    )
-    # create parallel tasks
-    tasks = []
-    for k, pt in prompts_parallel.items():
-        sk = summarization_kwargs.copy()
-        sk["prompt"] = pt
-        tasks.append(async_generate(llm=llm, docs=docs, summarization_kwargs=sk, k=k))
-    # execute all coroutines concurrently
-    values = await asyncio.gather(*tasks)
-
-    # report return values
-    print(values)
-    values_flattened = {}
-    for v in values:
-        values_flattened.update(v)
-    return values_flattened
-
-
-def parallel_summarization(
-    file: str, llm: ChatOpenAI, summarization_kwargs: dict
-) -> str:
-    """Wrapper for the summarization function to make it compatible with gradio.
-
-    Args:
-        file (str): Path to the file. This can either be a local path or a tempfile.TemporaryFileWrapper_.
-        llm (ChatOpenAI): Language model.
-        summarization_kwargs (dict): Keyword arguments for the summarization.
-
-    Returns:
-        str: Summarization of the file.
-    """
-    now = time.time()
-    values_flattened = asyncio.run(
-        generate_concurrently(file_path=file.name, llm=llm[0])
-    )
-    print("Time taken: ", time.time() - now)
-
-    output = f"""
-    
-{values_flattened["intro"]}
-
-{values_flattened["darstellung_des_rechtsproblems"]}
-
-
-II.  Die Entscheidung
-
-{values_flattened["angaben_ueber_das_urteil"]}
-
-{values_flattened["sachverhalt"]}
-
-{values_flattened["prozessgeschichte"]}
-
-{values_flattened["rechtsproblem"]}
-
-{values_flattened["loesung_des_gerichts"]}
-
-
-III.  Analyse
-
-{values_flattened["loesungsansaetze_zum_problem"]}
-
-{values_flattened["analyse_und_einordnung_der_entscheidung"]}
-
-{values_flattened["bewertung_und_kritik_der_entscheidung"]}
-
-{values_flattened["eigener_loesungsvorschlag"]}
-
-{values_flattened["ausblick"]}
-"""
-
-    return output