add app

README.md

@@ -1,12 +1,38 @@
----
-title: Neuro Internal Tools
-emoji: 🔥
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 3.36.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Paper Reader Tool
+
+Scientific papers are coming out TOO DAMN FAST so we need a way to very quickly extract useful information.
+
+## Repo Contents
+
+- `chat.py` - this file is a simple chatbot that will chat with you about the contents of `input.txt` (you can copy/paste anything into this text file). Very useful to quickly discuss papers. 
+- `generate_multiple_reports.py` - this will consume all PDFs in the `input/` folder and generate summaries in the `output/` folder. This is helpful for bulk processing such as for literature reviews. 
+- `render_report.py` - this will render all the reports in `output/` to  an *easier* to read file in `report.html`.
+- `GUI.py` - this will make a Gradio Interface where you select a pdf file from your desktop and then get the answers.
+## EXECUTIVE SUMMARY
+
+This repository contains Python scripts that automate the process of generating reports from PDF files using OpenAI's
+GPT-4 model. The scripts extract text from PDF files, send the text to the GPT-4 model for processing, and save the
+generated reports as text files. The scripts also include functionality to render the generated reports as an HTML
+document and Gradio GUI  for easy viewing.
+## SETUP
+
+1. Clone the repository to your local machine.
+2. Install the required Python packages by running `pip install -r requirements.txt` in your terminal.
+3. Obtain an API key from OpenAI and save it in a file named `key_openai.txt` in the root directory of the repository.
+4. Place the PDF files you want to generate reports from in the `input/` directory.
+
+## USAGE
+
+1. Run the `generate_multiple_reports.py` script to generate reports from the PDF files in the `input/` directory. The
+generated reports will be saved as text files in the `output/` directory.
+2. Run the `render_report.py` script to render the generated reports as an HTML document. The HTML document will be
+saved as `report.html` in the root directory of the repository.
+3. You can modify the `prompts` in `generate_multiple_reports.py` to focus on any questions you would like to ask. In other words you can automatically ask any set of questions in bulk against any set of papers. This can help you greatly accelerate your literature reviews and surveys.
+
+## NOTE
+
+The scripts are designed to handle errors and retries when communicating with the OpenAI API. If the API returns an
+error due to the maximum context length being exceeded, the scripts will automatically trim the oldest message and retry
+the API call. If the API returns any other type of error, the scripts will retry the API call after a delay, with the
+delay increasing exponentially for each consecutive error. If the API returns errors for seven consecutive attempts, the
+scripts will stop and exit.

app.py

@@ -0,0 +1,83 @@
+import gradio as gr
+import asyncio
+from core import chatbot, chat_print, estimate_costs
+import openai
+import PyPDF2
+from file_operations import open_file
+
+prompts = [
+    "Can you give me a very clear explanation of the core assertions, implications, and mechanics mentioned in this paper?",
+    "Can you give a short summary with bullet points and key takeaways",
+    "Can you give me an analogy or metaphor that will help explain this to a broad audience.",
+]
+
+
+async def process_prompt(prompt, ALL_MESSAGES, model):
+    report = ""
+    ALL_MESSAGES.append({"role": "user", "content": prompt})
+    response, tokens = await chatbot(ALL_MESSAGES, model)
+    chat_print(response)
+    ALL_MESSAGES.append({"role": "assistant", "content": response})
+    report += "\n\n\n\nQ: %s\n\nA: %s" % (prompt, response)
+    return report
+
+
+async def process_pdf_content(text, prompts):
+    model = "gpt-3.5-turbo-16k"
+    if len(text) > 22000:
+        text = text[:22000]
+        model = "gpt-4-32k"
+    prompt_tokens = len(text) / 0.75
+    for p in prompts:
+        prompt_tokens += len(p) / 0.75
+    costs = estimate_costs(prompt_tokens, model)
+    print(costs)
+    if costs > 2:
+        return f"THIS IS WAY TO MUCH {costs}"
+    else:
+        ALL_MESSAGES = [{"role": "system", "content": text}]
+        prompt_tasks = [process_prompt(p, ALL_MESSAGES, model) for p in prompts]
+        results = await asyncio.gather(*prompt_tasks)
+        return " ".join(results).strip()
+
+
+def process_pdf(pdf_file, prompt1, prompt2, prompt3):
+    # Open the PDF file
+    prompts = [
+        prompt for prompt in [prompt1, prompt2, prompt3] if prompt
+    ]  # Only include prompts that are not empty
+    pdf_reader = PyPDF2.PdfReader(pdf_file)
+    paper = ""
+    for page_num in range(len(pdf_reader.pages)):
+        page = pdf_reader.pages[page_num]
+        paper += page.extract_text()
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    task = process_pdf_content(paper, prompts)
+    result = loop.run_until_complete(task)
+
+    return result
+
+
+openai.api_key = open_file("key_openai.txt").strip()
+
+iface = gr.Interface(
+    fn=process_pdf,
+    inputs=[
+        gr.inputs.File(),
+        gr.inputs.Textbox(
+            lines=2, placeholder="Enter Prompt 1 Here...", label="Prompt 1"
+        ),
+        gr.inputs.Textbox(
+            lines=2, placeholder="Enter Prompt 2 Here...", label="Prompt 2"
+        ),
+        gr.inputs.Textbox(
+            lines=2, placeholder="Enter Prompt 3 Here...", label="Prompt 3"
+        ),
+    ],
+    outputs="text",
+    title="Paper Analyser",
+    description="This tool analyse your academic papers and returns key findings",
+)
+
+iface.launch()

core.py

@@ -0,0 +1,57 @@
+import asyncio
+import textwrap
+
+import openai
+from halo import Halo
+
+gpt_costs_per_thousand_out = {
+    "gpt-3.5-turbo-16k": 0.004,
+    "gpt-4-32k": 0.12,
+}
+gpt_costs_per_thousand_in = {
+    "gpt-3.5-turbo-16k": 0.003,
+    "gpt-4-32k": 0.06,
+}
+
+
+def estimate_costs(prompt_tokens, model: str):
+    costs = (prompt_tokens / 1000) * gpt_costs_per_thousand_in[model]
+    return costs
+
+
+async def chatbot(conversation, model, temperature=0):
+    max_retry = 7
+    retry = 0
+    while True:
+        try:
+            spinner = Halo(text="Thinking...", spinner="dots")
+            spinner.start()
+
+            response = await openai.ChatCompletion.acreate(
+                model=model, messages=conversation, temperature=temperature
+            )
+            text = response["choices"][0]["message"]["content"]
+            spinner.stop()
+
+            return text, response["usage"]
+        except Exception as oops:
+            print(f'\n\nError communicating with OpenAI: "{oops}"')
+            if "maximum context length" in str(oops):
+                a = conversation.pop(0)
+                print("\n\n DEBUG: Trimming oldest message")
+                continue
+            retry += 1
+            if retry >= max_retry:
+                print(f"\n\nExiting due to excessive errors in API: {oops}")
+                exit(1)
+            print(f"\n\nRetrying in {2 ** (retry - 1) * 5} seconds...")
+            await asyncio.sleep(2 ** (retry - 1) * 5)
+
+
+def chat_print(text):
+    formatted_lines = [
+        textwrap.fill(line, width=120, initial_indent="    ", subsequent_indent="    ")
+        for line in text.split("\n")
+    ]
+    formatted_text = "\n".join(formatted_lines)
+    print("\n\n\nCHATBOT:\n\n%s" % formatted_text)

file_operations.py

@@ -0,0 +1,22 @@
+import yaml
+
+
+def save_file(filepath, content):
+    with open(filepath, "w", encoding="utf-8") as outfile:
+        outfile.write(content)
+
+
+def open_file(filepath):
+    with open(filepath, "r", encoding="utf-8", errors="ignore") as infile:
+        return infile.read()
+
+
+def save_yaml(filepath, data):
+    with open(filepath, "w", encoding="utf-8") as file:
+        yaml.dump(data, file, allow_unicode=True)
+
+
+def open_yaml(filepath):
+    with open(filepath, "r", encoding="utf-8") as file:
+        data = yaml.load(file, Loader=yaml.FullLoader)
+    return data

key_openai.txt

@@ -0,0 +1 @@
+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

requirements.txt

@@ -0,0 +1,7 @@
+bs4
+halo
+openai
+pypdf2
+pyyaml
+gradio
+cffi