Upload 7 files

paper2slides.py

@@ -0,0 +1,703 @@
+slide_datasource = {
+    'introduction': ['abstract', 'Introduction'],
+    'objective': ['abstract', 'Introduction'],
+    'methodoloy': ['abstract', 'Introduction', 'Conclusion', 'Methods'],
+    'results': ['abstract', 'Experiments', 'Conclusion'],
+    'conclusion': ['abstract', 'Introduction', 'Conclusion'],
+}
+
+from pdf_helper import PDFPaper4LLMParser, dict_to_markdown_list
+from sambaAPI import call_llama_chat, MODEL_ALIAS
+from pdf_helper import markdown_to_slide_dicts
+from pptx_utils import Dict2PPT, os
+import json
+import time
+import string
+
+SLIDE_SEP = '<slide_sep>'
+
+def trim_string(s):
+    return s.strip(string.whitespace + string.punctuation)
+
+section_title_key_phrases = {
+    'Introduction': ['introduction'],
+    'Related Works': ['related work'],
+    'Methods': ['method', 'approach'],
+    'Experiments': ['experiment'],
+    'Conclusion': ['conclusion'],
+    'Acknowledgements': ['acknowledgement'],
+    'References': ['references', ' references'], #
+}
+
+def find_string_index(string_list, target: str):
+    """
+    Returns the index of the target string in the list.
+    If the target is not found, returns -1.
+
+    Parameters:
+    string_list (list): A list of strings
+    target (str): The string to find in the list
+
+    Returns:
+    int: The index of the target string, or -1 if not found
+    """
+    try:
+        return string_list.index(target)
+    except ValueError:
+        return -1
+
+
+def get_section_category(section_name: str):
+    """
+    Scientist paper section name mapping
+    """
+    for key, phrases in section_title_key_phrases.items():
+        for phrase in phrases:
+            if phrase in section_name.lower():
+                return key
+    return 'Other'
+
+
+class PaperReader(object):
+    def __init__(self, page_chunks=False):
+        self.paper_reader = PDFPaper4LLMParser(page_chunks=page_chunks)
+
+    def pdf2text(self, paper_pdf_path: str):
+        paper_content = self.paper_reader.run(pdf_path=paper_pdf_path, verbose=False)
+        return paper_content
+    
+    def structurize(self, main_text_array: list):
+        section_names = [_['title'] for _ in main_text_array]
+        section_name_topics = [get_section_category(_) for _ in section_names]
+        introduction_idx = find_string_index(section_name_topics, target='Introduction')
+        refference_idx = find_string_index(section_name_topics, target='References')
+        experiment_idx = find_string_index(section_name_topics, target='Experiments')
+        conclusion_idx = find_string_index(section_name_topics, target='Conclusion')
+        if refference_idx > 0:
+            for idx in range(len(section_name_topics)):
+                if idx < refference_idx:
+                    if section_name_topics[idx] == 'Other':
+                        section_name_topics[idx] = 'Methods'
+                elif idx > refference_idx:
+                    if not ('appendix' in section_name_topics[idx].lower()):
+                        section_name_topics[idx] = 'Appendix: ' + section_name_topics[idx]
+                else:
+                    continue
+            # print(section_name_topics)
+            if experiment_idx > 0:
+                for idx in range(experiment_idx +1, refference_idx):
+                    if section_name_topics[idx] == 'Methods':
+                        section_name_topics[idx] = 'Experiments'
+        # print(section_name_topics)
+        experiment_idx = find_string_index(section_name_topics, target='Experiments')
+        method_idx = find_string_index(section_name_topics, target='Methods')
+        relatedwork_idx = find_string_index(section_name_topics, target='Related Works')
+        ack_idx = find_string_index(section_name_topics, target='Acknowledgements')
+        
+        paper_structure_dict = {
+            'Introduction': [introduction_idx],
+            'Related Works': [relatedwork_idx],
+            'References': [refference_idx],
+            'Conclusion': [conclusion_idx],
+            'Acknowledgements': [ack_idx]
+        }
+
+        ## Experiments and methodology
+        method_idx_array = []
+        if method_idx >=0:
+            for idx in range(method_idx, len(section_name_topics)):
+                if section_name_topics[idx] == 'Methods':
+                    method_idx_array.append(idx)
+                else:
+                    break
+        else:
+            if introduction_idx >=0 and conclusion_idx >=0:
+                for idx in range(introduction_idx+1, conclusion_idx):
+                    if section_name_topics[idx] == 'Methods':
+                        method_idx_array.append(idx)
+                    else:
+                        break
+
+        
+        exp_idx_array = []
+        if experiment_idx >=0:
+            for idx in range(experiment_idx, len(section_name_topics)):
+                if section_name_topics[idx] == 'Experiments':
+                    exp_idx_array.append(idx)
+                else:
+                    break
+        else:
+            if introduction_idx >=0 and conclusion_idx >=0:
+                for idx in range(introduction_idx+1, conclusion_idx):
+                    if section_name_topics[idx] == 'Experiments':
+                        exp_idx_array.append(idx)
+                    else:
+                        break
+        
+        paper_structure_dict['Experiments'] = exp_idx_array
+        paper_structure_dict['Methods'] = method_idx_array
+        return section_name_topics, paper_structure_dict
+
+    def run(self, paper_file_name: str):
+        start_time = time.time()
+        paper_content = self.pdf2text(paper_pdf_path=paper_file_name)
+        section_name_topics, paper_structure_dict = self.structurize(main_text_array=paper_content['main_text'])
+        paper_content['structure'] = paper_structure_dict
+        paper_content['section_topic'] = section_name_topics
+        print('Runtime for pdf2text = {:.4f} seconds.'.format(time.time() - start_time))
+        return paper_content
+
+### 1. General System Prompt
+    
+SCHOLAR_PROMPT = """
+You are an assistant being skilled at critically reading and analyzing academic papers to extract key insights, trends, and findings.
+"""
+
+### 2. Paper Outline Generation from Abstract
+
+ABSTRACT_SUMMARY_PROMPT = """
+You are given the **title** and **abstract** of an academic paper. Please first identity the research topic, and then extract the following aspects in a minimal title draft (max 15 words) for PowerPoint presentation:
+	
+    1.	**Background**: Introduces the research context and importance.
+	2.	**Research Problem**: Identifies the specific problem or knowledge gap.
+	3.	**Objectives**: States the research goals or hypotheses.
+	4.	**Methodology**: Summarizes the research design and key methods.
+	5.	**Results**: Highlights the most significant findings.
+	6.	**Conclusions**: Provides the main takeaways and their relation to the research question.
+
+Reminder: Strictly output in JSON format **only**, using the keys: "Research topic", "Background", "Research problem", "Objectives", "Methodology", "Results" and "Conclusions".
+"""
+
+### 3. Evidence extraction from main paper text for "Background"
+BACKGROUD_EVIDENCE_PROMPT = """
+You are given the **title**, briefly description of **problem backgroud** and **introduction** of a research paper. From the introduction, extract an itemized list of **1 to 3 pieces of evidence** that support the problem background, each evidence should be described in a **minimal draft (min 10 words and max 25 words)** for PowerPoint presentation.
+
+    Each piece of evidence must:
+        1.	Be directly relevant to the problem background.
+        2.	Be clear and concise.
+        3.	Be unique, not repeating other evidence.
+
+**Important**: Strictly output the itemized evidences ONLY.
+"""
+
+
+### 4. Evidence extraction from main paper text for "Research Problem"
+RESEARCH_PROBLEM_PROMPT = """
+You are given the **title**, briefly description of **research problem** and **introduction** of a research paper. Solely from the given introduction, extract the definition of the research problem for PowerPoint presentation, focusing on:
+    
+    1.	**Scope**: Define the problem’s boundaries as individual items;
+	2.	**Challenges**: Identify key gaps or obstacles the research addresses as individual items;
+    3.  **Assumptions**: State any assumptions guiding the research as individual items;
+    4.  **Relevance*: Specify who benefits from solving the problem as individual items.
+
+**Note**: Each item must be in one concise sentence. **Only** output "Scope", "Challenges", "Assumptions" and "Relevance".
+"""
+
+
+### 5. Evidence extraction from main paper text for "Objectives"
+
+OBJECTIVE_PROMPT = """
+You are given the **title**, **objectives** and **introduction** of a research paper. Solely from the given introduction, extract a list of **2 to 5 pieces of evidence** to support these objectives, each evidence should be described in a **minimal draft (min 10 words and max 20 words)** for PowerPoint presentation.
+
+    Each piece of evidence must:
+        1.	Be directly relevant to the objectives.
+        2.	Be clear and concise.
+        3.	Be unique, not repeating other evidence.
+    
+**Note**: Strictly output the itemized evidences ONLY.
+"""
+
+### 6. Evidence extraction from main paper text for "Conclusion"
+
+CONCLUSION_PROMT = """
+You are given the **title**, **birief conclusion**, and **full text conclusion** and **introduction** of a research paper. From the given conclusion and introduction, extract the **conclusion** for PowerPoint presentation, ensuring it includes:
+
+	1.	**Summary of key results**: Highlight the main results.
+	2.	**Implications**: Explain the significance or impact of these findings.
+	3.	**Future directions**: Mention any suggestions for future research or applications.
+	4.	**Final takeaway**: Provide the overall takeaway message of the study.
+
+**Note**: Only output the conclusion. Limit each point in a minimal concise draft (at least 10 words).”
+"""
+
+### 7. Evidence extraction from main paper text for "Experimental results" (iterative)
+
+RESULT_PROMPT_DICT = {
+  "system_instruction": """Given the title, the main results of an experimental study, and a paragraph from a research paper, your task is to extract and summarize evidence from the paragraph that supports the 'main results'.
+
+   Follow these steps for each paragraph:
+        1.	**Detect Evidence**: Check if the paragraph contains:
+            1) Any evidence supporting the main results, or
+            2) Experimental study information, including:
+                - **Dataset**: Details on datasets, preprocessing, or train/test splits.
+                - **Model Description**: Information of baselines, hyperparameters, and training.
+                - **Evaluation Metrics**: Relevant metrics like accuracy, F1 score, and their justification.
+                - **Comparative Analysis**: Comparisons with baselines, ablation studies, statistical significance.
+                - **Runtime & Scalability**: Computational complexity and scalability.
+        2.	**Response**: Choose 'YES' or 'NO':
+            - If 'YES', extract and summarize the evidence or experimental details in 200 words. Ensure the summary is:
+                - Clear and concise
+                - Well-formatted for easy reading
+                - Focused on key points: dataset, model Description, evaluation metrics, comparative analysis and runtime & scalability.
+            - If 'NO', just respond with 'NO EVIDENCE'.
+  """,
+
+  "iterative_prompt": """Summarize the experimental details or evidence supporting the 'main results' in 200 words from the following paragraph (with title and content) if experiment-related information is detected. Follow these instructions:
+
+	1.	List 2 to 4 itemized points.
+	2.	Each point must specify the type ('Evidence' or 'Experimental Setup') and provide a minimal draft sentence of content (max 15 words).
+
+**Note**: Only provide the itemized summary.
+  """,
+
+  "final_prompt": """Using the **title**, the **main results** of an experimental study, and a list of experiment summaries from the research paper, follow these steps to summarize the results:
+
+	1.	**Evidence Summary**: prive a numbered, itemized summary of **2-3** key points. Keep each point brief and focused (only 1 sentence).
+
+	2.	**Experimental Summary**: Based all 'Experimental Setup' points and provide a concise summary covering the following aspects:
+        1) **Datasets**: List only the names of all datasets or benchmarks used.
+        2) **Baselines**: List only the names of all models/algorithms used.
+        3) **Metrics**: List only the evaluation metrics used for model performance, such as accuracy, F1-score, recall, precision, AUC, etc.
+        4) **Results**: Summarize key comparisons and ablation results, focusing on the most important details.
+
+  **Note**: Only output the “Evidence Summary” and “Experimental Summary”
+     """
+}
+
+## Methodology extraction
+
+METHOD_PROMPT_DICT = {
+    "system_instruction": """Given the **title**, the **method overview**, and a paragraph of a research paper. You task is identify and extract text being relevant to 'method overview' from the given paragraph for PowerPoint presentation.
+
+    Follow these steps:
+    1. **Method Information Detection**: Check if the paragraph contains:
+       1) Any mention of the **method overview** or
+       2) Specific method details, such as:
+           - **Problem Definition**: The task, input, and expected output.
+           - **Model Architecture**: Structure, key components, and learning type.
+           - **Algorithm**: Steps of the method.
+           - **Training Process**: Training data, optimization method, and loss function.
+    2. **Response**: Choose 'YES' or 'NO':
+        - If 'YES', summarize the method details in a minimal draft with max 20 words, ensuring it is:
+            - Clear and concise
+            - Well-formatted for readability
+            - Focused on key points.
+        - If 'NO', simply respond with 'NO Information'.
+    """,
+    "iterative_prompt": """Summarize the method description in 200 words from the following paragraph (with title and content) if method-related information is found. Follow these steps:
+        
+        1. List **2 to 4** method steps in numbered format..
+        2. Ensure each step is related to the **method overview**.
+        3. Keep each step clear and concise (only minimal draft with max 15 words).
+    
+    **Note**: Only output the itemized method steps.
+    """,
+
+    "final_prompt": """Using **title**, **method overview**, and a list of itemized method step summary from a research paper, follow these instructions to summarize the method description::
+        
+        1. Provide a numbered list of **3-6 method steps** detailing the **method overview**.
+        2. Keep each step clear and concise (only 1 sentence).
+    
+    **Note**: Only output the itemized method steps.
+    """
+}
+
+SLIDES_REVISION_PROMPT = """You are an expert research assistant. Revise the following research paper slides to enhance clarity and readability while preserving the original markdown structure. Keep all first-level markdown headers unchanged. Sections are separated by '{}'. Follow these guidelines:
+
+	1.	Simplify language and make content more concise, especially in the outline.
+	2.	Preserve the logical flow and overall structure.
+	3.	Make key points and conclusions clear and easy to follow.
+	4.	Use bullet points where appropriate for better clarity.
+	5.	Minimize jargon to ensure accessibility for a broad academic audience.
+
+""".format(SLIDE_SEP)
+
+def make_api_call(model, messages, max_tokens, temperature):
+    try:
+        response = call_llama_chat(messages=messages, model=model, temperature=temperature, max_tokens=max_tokens)
+        return response
+    except Exception as e:
+         return f"Failed to generate final answer. Error: {str(e)}", {}
+
+def convert_to_dict(input_string: str):
+    # Split the string by the delimiter (e.g., semicolon)
+    lines = input_string.strip().split('\n')
+    # Initialize an empty dictionary
+    result_dict = {}
+    # Iterate over each line
+    for line in lines:
+        # Split each line into key and value by the delimiter (e.g., colon)
+        if ':' in line:
+            key, value = line.split(':', 1)  # Split only on the first occurrence
+            # Strip any whitespace and store in the dictionary
+            result_dict[key.strip()] = value.strip()
+    return result_dict
+
+
+class Paper2Slides(object):
+    def __init__(self, paper_contents: dict, model: str, max_tokens = 512, temprature=0.1):
+        self.paper_contents = paper_contents
+        if not self.valid_paper_checking():
+            print('Not a valid paper structure, cannot generate slides')
+            exit(1)
+        self.model = MODEL_ALIAS[model]
+        self.is_rate_limitation = ('405B' in self.model) or ('70B' in self.model)
+        self.temprature = temprature
+        self.max_failure_attempt_each_step = 3
+        if '405B' in self.model:
+            self.sleep_time = 0.25
+        else:
+            self.sleep_time = 0.25
+        self.max_tokens = max_tokens
+        print('{} model is used for slides generation!\nRate limitation = {}'.format(self.model, self.is_rate_limitation))
+        self.revise_model = MODEL_ALIAS['llama3_70b']
+    
+    def valid_paper_checking(self):
+        try:
+            assert 'abstract' in self.paper_contents, 'No abstract is detected'
+            assert 'title' in self.paper_contents, 'No title is detected'
+            paper_structure = self.paper_contents['structure']
+            introduction_idx_array = paper_structure['Introduction']
+            conclusion_idx_array = paper_structure['Conclusion']
+            assert introduction_idx_array[0] >=0, 'No introduction is detected'
+            assert conclusion_idx_array[0] >=0, 'No conclusion is detected'
+        except AssertionError as e:
+            print(f"AssertionError: {e}")
+            return False
+        return True
+
+    def step(self, messages):
+        result = self.run(messages=messages)
+        if 'Failed' in result:
+            time.sleep(self.sleep_time)
+        if self.is_rate_limitation:
+            print('sleep {} seconds'.format(self.sleep_time))
+            time.sleep(self.sleep_time)
+        return result
+    
+    def run(self, messages):
+        for attempt in range(self.max_failure_attempt_each_step):
+            try:
+                response = make_api_call(messages=messages, model=self.model, max_tokens=self.max_tokens, temperature=self.temprature)
+                return response
+            except Exception as e:
+                if attempt == self.max_failure_attempt_each_step - 1:
+                    return "Failed to generate step after {} attempts. $ERROR$: {}".format(self.max_failure_attempt_each_step, str(e))
+                else:
+                    return "Failed to generate step. $ERROR$: {}".format(str(e))
+                time.sleep(2)  # Wait for 1 second before retrying
+        return 'Failed to generate reasoning step.'
+        
+    
+    def abstract_summary(self):
+        """
+        Extract the outline for the slides from abstract
+        """
+        assert len(self.paper_contents['title']) > 0 and len(self.paper_contents['abstract']) > 512
+        prompt = "**title**: {}\n\n**abstract**: {}".format(self.paper_contents['title'], self.paper_contents['abstract'])
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": ABSTRACT_SUMMARY_PROMPT},
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
+        ]
+        abstract_summary = self.step(messages=messages)
+        try:
+            abstract_summary_dict = json.loads(abstract_summary)
+        except Exception as e:
+            abstract_summary_dict = convert_to_dict(input_string=abstract_summary)
+        
+        trim_abstract_summary_dict = {}
+        for k, v in abstract_summary_dict.items():
+            trim_abstract_summary_dict[trim_string(k)] = v
+        return trim_abstract_summary_dict
+
+    def support_background(self, background: str, introduction: str):
+        """
+        Extract support evidences for background from introduction
+        """
+        prompt = "**title**: {}\n\n**promblem background**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], background, introduction)
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": BACKGROUD_EVIDENCE_PROMPT},
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
+        ]
+        evidences = self.step(messages=messages)
+        # print('Background evidences = {}'.format(evidences))
+        step_num = 1
+        return evidences, step_num
+
+    def support_research_problem(self, research_problem: str, introduction: str):
+        """
+        Extract support evidences for research problem from introduction
+        """
+        prompt = "**title**: {}\n\n**research problem**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], research_problem, introduction)
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": RESEARCH_PROBLEM_PROMPT},
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
+        ]
+        evidences = self.step(messages=messages)
+        step_num = 1
+        return evidences, step_num
+    
+    def support_objectives(self, objectives: str, introduction: str):
+        """
+        Extract support evidences for objectives from introduction
+        """
+        prompt = "**title**: {}\n\n**objectives**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], objectives, introduction)
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": OBJECTIVE_PROMPT},
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "I will extract the evidences following my instructions."}
+        ]
+        evidences = self.step(messages=messages)
+        step_num = 1
+        return evidences, step_num
+
+    def support_conclusion(self, conclusion: str, introduction: str, conclusion_text: str, step_wise=True):
+        """
+        Expand conclusion based on full-text conclusion and introducton. 
+        If step_wise = True:
+            1. Summarize introduction while focusing on conclusion part
+            2. Extract conclusion points from introduction summary and full-context conclusion.
+        """
+        step_num = 0
+        prompt = "**title**: {}\n\n**introduction**: {}".format(self.paper_contents['title'], introduction)
+        if step_wise:
+            messages = [
+                {"role": "system", "content": SCHOLAR_PROMPT},
+                {"role": "system", "content": "Given a **tititle** and **introduction** of a research paper, summarize and extract conclusion related information in about 200 words."},
+                {"role": "user", "content": prompt},
+                {"role": "assistant", "content": "I will extract the conclusion following my instructions."}
+            ]
+            instruction_conclusion_summary = self.step(messages=messages)
+            step_num = step_num + 1
+        else:
+            instruction_conclusion_summary = introduction
+
+        prompt = "**title**: {}\n\n**brief conclusion**: {}\n\n**conclusion**: \n\n{}**introduction**: {}".format(self.paper_contents['title'], conclusion, conclusion_text, instruction_conclusion_summary)
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": CONCLUSION_PROMT},
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "I will extract the conclusions following my instructions."}
+        ]
+        evidences = self.step(messages=messages)
+        step_num = step_num + 1
+        return evidences, step_num
+    
+    def support_experiment_results(self, main_results: str, paragraph_list: list):
+        step_num = 0
+        prompt = "**title**: {}\n\n**main results**: {}\n\n".format(self.paper_contents['title'], main_results)
+        iterative_sys_prompt = RESULT_PROMPT_DICT['iterative_prompt']
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": RESULT_PROMPT_DICT['system_instruction']},
+            {"role": "user", "content": prompt},
+            {"role": "system", "content": iterative_sys_prompt},
+        ]
+
+        follow_instruction = {"role": "assistant", "content": "I will extract the experimental information following my instructions."}
+
+        paragraph_summary_array = []
+        for para_idx in range(len(paragraph_list)):
+            para_input_prompt = "Paragraph title: {}\n\nContent: {}\n\n".format(paragraph_list[para_idx]['title'], paragraph_list[para_idx]['content'])
+            user_input = {'role': 'user', 'content': para_input_prompt}
+            messages.append(user_input)
+            messages.append(follow_instruction)
+            para_summary = self.step(messages=messages)
+            step_num = step_num + 1
+            paragraph_summary_array.append(para_summary)
+            messages.pop()
+            messages.pop()
+
+        ## Experimental result summary
+
+        prompt = "**title**: {}\n\n**main results**: {}\n\n".format(self.paper_contents['title'], main_results)
+        summary_prompt = '\n'.join(['**summary** {}:\n\n{}'.format(idx+1, summary) for idx, summary in enumerate(paragraph_summary_array)])
+        input_prompt = prompt + summary_prompt
+
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": RESULT_PROMPT_DICT['final_prompt']},
+            {"role": "user", "content": input_prompt},
+            {"role": "assistant", "content": "I will summarize the experimental results following my instructions."},
+        ]
+
+        result_summary = self.step(messages=messages)
+        step_num = step_num + 1
+        return result_summary, step_num
+
+    def experiment_paragraph_extraction(self,):
+        intro_idx = self.paper_contents['structure']['Introduction'][0]
+        conclusion_idx = self.paper_contents['structure']['Conclusion'][0]
+        experiment_idx_array = self.paper_contents['structure']['Experiments']
+        if len(experiment_idx_array) == 0:
+            experiment_idx_array = [_ for _ in range(intro_idx+1, conclusion_idx)]
+        assert len(experiment_idx_array) > 0 and max(experiment_idx_array) < len(self.paper_contents['main_text'])
+        experiment_idx_array = [intro_idx] + experiment_idx_array
+        paragraphs = [self.paper_contents['main_text'][_] for _ in experiment_idx_array]
+        return paragraphs
+    
+    def support_methodology(self, method_overview: str, paragraph_list: list):
+        step_num = 0
+        prompt = "**title**: {}\n\n**method overview**: {}\n\n".format(self.paper_contents['title'], method_overview)
+        iterative_sys_prompt = METHOD_PROMPT_DICT['iterative_prompt']
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": METHOD_PROMPT_DICT['system_instruction']},
+            {"role": "user", "content": prompt},
+            {"role": "system", "content": iterative_sys_prompt},
+        ]
+
+        follow_instruction = {"role": "assistant", "content": "I will extract the method information following my instructions."}
+
+        method_summary_array = []
+        for para_idx in range(len(paragraph_list)):
+            para_input_prompt = "Paragraph title: {}\n\nContent: {}\n\n".format(paragraph_list[para_idx]['title'], paragraph_list[para_idx]['content'])
+            user_input = {'role': 'user', 'content': para_input_prompt}
+            messages.append(user_input)
+            messages.append(follow_instruction)
+            method_summary = self.step(messages=messages)
+            step_num = step_num + 1
+            method_summary_array.append(method_summary)
+            messages.pop()
+            messages.pop()
+
+        ## Method summary
+        prompt = "**title**: {}\n\n**method overview**: {}\n\n".format(self.paper_contents['title'], method_overview)
+        method_summary_prompt = '\n'.join(['**method summary** {}:\n\n{}'.format(idx+1, summary) for idx, summary in enumerate(method_summary_array)])
+        input_prompt = prompt + method_summary_prompt
+
+        messages = [
+            {"role": "system", "content": SCHOLAR_PROMPT},
+            {"role": "system", "content": METHOD_PROMPT_DICT['final_prompt']},
+            {"role": "user", "content": input_prompt},
+            {"role": "assistant", "content": "I will generate a step-by-step method summary following my instructions."},
+        ]
+        method_summary = self.step(messages=messages)
+        step_num = step_num + 1
+        return method_summary, step_num
+        
+    def method_paragraph_extraction(self,):
+        intro_idx = self.paper_contents['structure']['Introduction'][0]
+        conclusion_idx = self.paper_contents['structure']['Conclusion'][0]
+        method_idx_array = self.paper_contents['structure']['Methods']
+        if len(method_idx_array) == 0:
+            method_idx_array = [_ for _ in range(intro_idx+1, conclusion_idx)]
+        assert len(method_idx_array) > 0 and max(method_idx_array) < len(self.paper_contents['main_text'])
+        method_idx_array = [intro_idx] + method_idx_array
+        paragraphs = [self.paper_contents['main_text'][_] for _ in method_idx_array]
+        return paragraphs
+
+    def generate_slides(self, verbose=False, revision=True):
+        ## Step 1: Paper content extraction
+        intro_idx = self.paper_contents['structure']['Introduction'][0]
+        introduction = self.paper_contents['main_text'][intro_idx]['content']
+        assert len(introduction) > 512, 'introduction = {}, content = {}'.format(introduction, self.paper_contents['main_text'])
+        conclusion_idx = self.paper_contents['structure']['Conclusion'][0]
+        conclusion = self.paper_contents['main_text'][conclusion_idx]['content']
+        assert len(conclusion) > 128, 'conclusion = {}, content = {}'.format(introduction, self.paper_contents['main_text'])
+        method_paragraphs = self.method_paragraph_extraction()
+        experiment_paragraphs = self.experiment_paragraph_extraction()
+
+        start_time = time.time()
+        ## Step 2: slides structure extraction from abstract
+        model_call_number = 0
+        print('Slides structure generation')
+        slides = {'Title': self.paper_contents['title']}
+        outline_dict = self.abstract_summary()
+        model_call_number += 1
+        slides['Outline'] = outline_dict
+
+        print('Slides generation...')
+        background = outline_dict.get('Background', '')
+        slides['Background'], b_steps = self.support_background(background=background, introduction=introduction)
+        model_call_number += b_steps
+
+        research_problem = outline_dict.get('Research problem', '')
+        slides['Research problem'], r_steps = self.support_research_problem(research_problem=research_problem, introduction=introduction)
+        model_call_number += r_steps
+        
+        objectives = outline_dict.get('Objectives', '')
+        slides['Objectives'], o_steps = self.support_objectives(objectives=objectives, introduction=introduction)
+        model_call_number += o_steps
+
+        brief_conclusion = outline_dict.get('Conclusions', '')
+        slides['Conclusions'], c_steps = self.support_conclusion(conclusion=brief_conclusion, introduction=introduction, conclusion_text=conclusion, step_wise=True)
+        model_call_number += c_steps
+
+        results = outline_dict.get('Results', '')
+        result_summary, res_steps = self.support_experiment_results(main_results=results, paragraph_list=experiment_paragraphs)
+        slides['Results'] = result_summary
+        model_call_number += res_steps
+
+        methodology = outline_dict.get('Methodology', '')
+        method_summary, m_steps = self.support_methodology(method_overview=methodology, paragraph_list=method_paragraphs)
+        model_call_number += m_steps
+        slides['Methodology'] = method_summary
+        runtime = time.time() - start_time
+        print('Slide generation takes {:.4f} seconds with {} function calls'.format(runtime, model_call_number))
+        if verbose:
+            slides_content = self.slides2markdown_v2(slides=slides)
+            if revision:
+                slides_content = self.slides_revision(slide_content=slides_content)
+                slides_array = markdown_to_slide_dicts(full_markdown=slides_content)
+                revised_slides = {k: v for d in slides_array for k, v in d.items()}
+                if verbose:
+                    print('Json format:\n{}'.format(json.dumps(revised_slides, indent=4)))
+                    print('\n' * 3)
+                    print('paper keywords:\n{}'.format(self.paper_contents.keys()))
+                return revised_slides
+            if verbose:
+                print('Generated slides:\n{}'.format(slides_content))
+                print('Json format:\n{}'.format(json.dumps(slides, indent=4)))
+        return slides
+    
+    def slides_revision(self, slide_content: str):
+        messages = [
+            {"role": "system", "content": SLIDES_REVISION_PROMPT},
+            {"role": "user", "content": slide_content},
+            {"role": "assistant", "content": "I will revise the representation slides following my instructions."}
+        ]
+        print('Slides final revision')
+        revised_slides = make_api_call(model=self.revise_model, messages=messages, max_tokens=2048, temperature=self.temprature)
+        return revised_slides
+
+    def slides2markdown(self, slides: dict):
+        slides_content = ''
+        slides_content += '**Title**\n{}\n\n'.format(slides['Title'])
+        slides_content += '{}\n'.format(SLIDE_SEP)
+        slides_content += '**Outline**\n\n'
+        outline_dict = slides['Outline']
+        for sect_name, sect_content in outline_dict.items():
+            slides_content += '{}\n--\t\t{}\n\n'.format(sect_name, sect_content)
+        slides_content += '{}\n'.format(SLIDE_SEP)
+        for sect_name in outline_dict.keys():
+            if sect_name in slides:
+                slides_content += '**{}**\n\n'.format(sect_name)
+                slides_content += '{}\n\n'.format(slides[sect_name])
+                slides_content += '{}\n'.format(SLIDE_SEP)
+        return slides_content
+    
+    def slides2markdown_v2(self, slides: dict, indent=0):
+        slides_content = dict_to_markdown_list(d=slides, indent=indent)
+        return slides_content
+
+    def save_to_slides(self, slides: dict, logo_path='logo.png', file_name='slides.pptx'):
+        authors = self.paper_contents.get('author', None)
+        if isinstance(authors, list):
+            authors = authors[0]
+        else:
+            authors = None
+        # print('authors', authors)
+        dict2ppt = Dict2PPT(logo_path=logo_path)
+        dict2ppt.build_slides(slide_dict=slides, authors=authors)
+        dict2ppt.save(file_name=file_name)
+        full_path = os.path.abspath(file_name)
+        return full_path
+

pdf_helper.py

@@ -0,0 +1,181 @@
+import pdf4llm
+import re
+
+def py4llm_pdf_reader(pdf_path: str):
+    md_text = pdf4llm.to_markdown(pdf_path)
+    return md_text
+
+def split_markdown_sections(text):
+    # Regex to match headers (e.g., #, ##, ###)
+    header_pattern = r'^(#{1,6})\s*(.+)$'
+    
+    # Find all headers and their positions
+    matches = list(re.finditer(header_pattern, text, re.MULTILINE))
+    
+    sections = []
+    
+    # Iterate over all header matches and split text
+    for i, match in enumerate(matches):
+        header = match.group(0)  # Full header text: number of # and header name
+        level = len(match.group(1))  # Header level (number of #)
+        title = match.group(2)  # Header title
+        
+        # Find the start position of the section (right after the header)
+        start_pos = match.end()
+        
+        # Find the end position (start of the next header or end of the document)
+        if i + 1 < len(matches):
+            end_pos = matches[i + 1].start()
+        else:
+            end_pos = len(text)
+        
+        # Extract section content between this header and the next one
+        section_content = text[start_pos:end_pos].strip()
+        
+        # Store the section as a tuple: (header level, header title, section content)
+        sections.append({'level': level, 'title': title, 'content': section_content})
+    
+    return sections
+
+
+class PDFPaper4LLMParser(object):
+    def __init__(self, write_images=False, page_chunks=False) -> None:
+        self.write_images = write_images
+        self.page_chunks = page_chunks
+
+    def pdf2text(self, pdf_path: str):
+        md_text = pdf4llm.to_markdown(pdf_path, write_images=self.write_images, page_chunks=self.page_chunks)
+        if self.page_chunks:
+            text_array = []
+            for md_text_i in md_text:
+                text_array.append(md_text_i['text'])
+            markdown_text = '\n'.join(text_array)
+        else:
+            markdown_text = md_text
+        return markdown_text
+    
+    def structured_paper_content(self, markdown_sections: list):
+        """
+        markdown_sections: list of dictionary, each dictionary consists of
+        1. level
+        2. title
+        3. content
+
+        Title, Author, Abstract, Section_i (i = 1, 2, 3, ...)
+        """
+        assert len(markdown_sections) > 0
+        struct_sections = {}
+        start_section = markdown_sections[0]
+        title_level = start_section['level']
+        
+        main_text_idx = -1
+        meta_data = []
+        for sec_idx, section in enumerate(markdown_sections):
+            level_i = section['level']
+            title_i = section['title']
+            content_i = section['content']
+            if level_i == title_level and sec_idx == 0:
+                struct_sections['title'] = title_i
+                if len(content_i) > 0:
+                    meta_data.append(content_i)
+            else:
+                if 'abstract' in title_i.lower() or 'abstract' in content_i.lower():
+                    struct_sections['abstract'] = content_i
+                    main_text_idx = sec_idx + 1
+                    break
+                else:
+                    meta_data.append(title_i + content_i)
+        struct_sections['author'] = meta_data
+        if main_text_idx == -1 and len(markdown_sections) > 0:
+            main_text_idx = 0
+        assert main_text_idx >= 0
+        main_text_list = markdown_sections[main_text_idx:]
+        struct_sections['main_text'] = main_text_list
+        return struct_sections
+
+    def run(self, pdf_path: str, verbose=True):
+        markdown_text = self.pdf2text(pdf_path=pdf_path)
+        sections = split_markdown_sections(text=markdown_text)
+        struct_sections = self.structured_paper_content(markdown_sections=sections)
+        if verbose:
+            paper_text = ''
+            for k, v in struct_sections.items():
+                if k == 'title':
+                    paper_text += '\nTitle: ' + v + '\n\n'
+                elif k == 'abstract':
+                    paper_text += '\nAbstract: \n'  + v + '\n\n'
+                elif k == 'author':
+                    paper_text += '\nAuthor: \n'  + '\n'.join(v) + '\n\n'
+                elif k == 'main_text':
+                    for section in v:
+                        paper_text += '\n' + section['title'] + '\n\n' + section['content'] + '\n\n'
+            print(paper_text)
+        return struct_sections
+
+
+def dict_to_markdown_list(d: dict, indent=0):
+    lines = []
+    for key, value in d.items():
+        prefix = '  ' * indent + f"- **{key}**: "
+        if isinstance(value, dict):
+            lines.append(prefix)
+            lines.append(dict_to_markdown_list(value, indent + 1))
+        else:
+            lines.append(prefix + str(value))
+    return "\n".join(lines)
+
+
+def split_markdown_slides(markdown: str, sep: str = "<slide_sep>"):
+    return [slide.strip() for slide in markdown.strip().split(sep) if slide.strip()]
+
+
+def parse_slide_to_dict(slide: str):
+    lines = slide.splitlines()
+    result = {}
+    current_key = None
+    sub_items = []
+
+    for line in lines:
+        line = line.strip()
+
+        # Capture headings (### or ##)
+        heading_match = re.match(r"^#{2,3}\s+(.*)", line)
+        if heading_match:
+            if current_key and sub_items:
+                result[current_key] = sub_items
+                sub_items = []
+            current_key = heading_match.group(1).strip()
+            continue
+
+        # Capture numbered list
+        numbered_match = re.match(r"^\d+\.\s+(.*)", line)
+        if numbered_match:
+            sub_items.append(numbered_match.group(1).strip())
+            continue
+
+        # Capture bulleted list
+        bullet_match = re.match(r"^[\*\-]\s+(.*)", line)
+        if bullet_match:
+            sub_items.append(bullet_match.group(1).strip())
+            continue
+
+        # Capture nested bullets
+        nested_bullet_match = re.match(r"^\s{2,}[\*\-]\s+(.*)", line)
+        if nested_bullet_match:
+            sub_items.append(nested_bullet_match.group(1).strip())
+            continue
+
+        # Fallback: add as freeform text
+        if current_key:
+            sub_items.append(line)
+
+    # Save the last block
+    if current_key and sub_items:
+        result[current_key] = sub_items
+
+    return result
+
+
+def markdown_to_slide_dicts(full_markdown: str):
+    slides = split_markdown_slides(full_markdown)
+    return [parse_slide_to_dict(slide) for slide in slides]

pptx_utils.py

@@ -0,0 +1,695 @@
+from pptx import Presentation
+from pptx.dml.color import RGBColor
+from pptx.util import Inches
+from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
+from pptx.util import Pt
+import string
+from datetime import datetime
+import os
+import re
+
+def clean_leading_numbering(text):
+    # Remove leading numbering like: "1. ", "1) ", "(1) ", "- 1. ", etc.
+    return re.sub(r'^[\s\(\-\.\d\)]*', '', text)
+
+def is_logo_exist(file_path: str):
+    print(file_path)
+    if os.path.exists(file_path):
+        # print("File exists.")
+        return True
+    else:
+        print("File does not exist.")
+        return False
+
+class Dict2PPT:
+    def __init__(self, logo_path: str = 'logo.png', title_size: int = 32, content_size: int=24) -> None:
+        self.title_font_size = Pt(title_size)
+        self.content_font_size = Pt(content_size)
+        self.logo_path = logo_path
+        self.prs = Presentation()
+
+    def _title_preprocess(self, title: str):
+        words = title.split()
+        capitalized_words = [word.capitalize() for word in words]
+        result = ' '.join(capitalized_words)
+        return  result
+
+    def _add_time_footnote(self, slide):
+        # Get slide dimensions
+        slide_width = self.prs.slide_width
+        slide_height = self.prs.slide_height
+
+        # Prepare date text
+        date_str = datetime.today().strftime("%B %d, %Y")  # e.g., March 26, 2025
+
+        # Set textbox size
+        textbox_width = Inches(3)  # You can adjust this
+        textbox_height = Inches(0.3)
+        left = (slide_width - textbox_width) / 2  # Center horizontally
+        top = slide_height - Inches(0.5)  # Near bottom
+
+        textbox = slide.shapes.add_textbox(left, top, textbox_width, textbox_height)
+        text_frame = textbox.text_frame
+        p = text_frame.paragraphs[0]
+        run = p.add_run()
+        run.text = date_str
+        run.font.size = Pt(12)
+        p.alignment = PP_ALIGN.CENTER  # ✅ Center text horizontally
+
+    def _add_logo(self, slide):
+        # Define logo path and size
+        # logo_path = "logo.png"  # Replace with your actual logo path
+
+        if not is_logo_exist(file_path=self.logo_path):
+            return
+        logo_width = Inches(1.0)  # Resize logo as needed
+        logo_height = Inches(1.0)
+
+        # Calculate position for top-right corner
+        slide_width = self.prs.slide_width
+        right_margin = Inches(0.2)  # Optional small margin from edge
+        top = Inches(0.2)
+
+        # Position: from right edge minus logo width
+        left = slide_width - logo_width - right_margin
+
+        # Add logo
+        slide.shapes.add_picture(self.logo_path, left, top, width=logo_width, height=logo_height)
+
+    def _set_background_color(self, slide):
+        fill = slide.background.fill
+        fill.solid()  # Use solid color
+        fill.fore_color.rgb = RGBColor(240, 248, 255)  # RGB for a light blue
+
+    def title_slide(self, title: str, authors: str):
+        title_slide_layout = self.prs.slide_layouts[0]  # Title Slide
+        slide = self.prs.slides.add_slide(title_slide_layout)
+
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+
+        title_shape = slide.shapes.title
+        title_shape.text = title
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 44 pt
+
+        author_shape = slide.placeholders[1]
+        today = datetime.today().strftime("%B %d, %Y")  # e.g., March 25, 2025
+        # print('authors', authors)
+        # if authors:
+        #     author_shape.text = '\n' + authors + '\n' + today
+        # else:
+        #     author_shape.text = '\nAuthor Here\n' + today
+        author_shape.text = '\nAuthor Here\n' + today
+        # Set subtitle font size
+        author_paragraph = author_shape.text_frame.paragraphs[1]  # 0 is blank line, 1 is actual text
+        for run in author_paragraph.runs:
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(24)  # Set subtitle font size to 28 pt
+
+    def outline_slide(self, outline: dict):
+        content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+        slide = self.prs.slides.add_slide(content_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+        title_shape = slide.shapes.title
+        title_shape.text = 'Outline'
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        title_paragraph.alignment = PP_ALIGN.LEFT
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 36 pt
+
+        # Clear existing content
+        content_shape = slide.placeholders[1]
+        text_frame = content_shape.text_frame
+        text_frame.clear()
+
+        # Add topic
+        for topic, desc in outline.items():
+            p1 = text_frame.add_paragraph()
+            p1.text = topic
+            p1.level = 0
+            p1.font.size = Pt(20)
+            p1.font.name = 'Times New Roman'
+            p1.font.bold = True
+            p1.alignment = PP_ALIGN.LEFT
+
+            # Line 2: description (indented)
+            if len(desc) > 0:
+                p2 = text_frame.add_paragraph()
+                p2.text = desc
+                p2.level = 1  # Indented bullet
+                p2.font.size = Pt(12)
+                p2.font.name = 'Times New Roman'
+                p2.alignment = PP_ALIGN.LEFT
+
+        self._add_time_footnote(slide=slide)
+
+    def _outline_preprocess_(self, outline):
+        if isinstance(outline, dict):
+            clean_outline = {}
+            for topic, desc in outline.items():
+                topic = topic.strip().strip(string.punctuation).strip()
+                desc = desc.strip().strip(string.punctuation).strip()
+                clean_outline[topic] = desc
+            return clean_outline
+
+        elif isinstance(outline, str):
+            sentences = outline.split('\n')
+            sentences = [text.strip().strip(string.punctuation).strip() for text in sentences]
+            sent_dict = {}
+            for sent in sentences:
+                tokens = sent.split(':')
+                if len(tokens) == 1:
+                    sent_dict[tokens[0]] = ''
+                else:
+                    key = tokens[0].strip().strip(string.punctuation).strip()
+                    value = ''.join(tokens[1:])
+                    value = value.strip().strip(string.punctuation).strip()
+                    sent_dict[key] = value
+            return sent_dict
+        else:
+            print('Wrong format')
+            return {}
+
+    def _background_preprocess(self, background: str):
+        background_array = []
+        sentences = background.strip().splitlines()
+        for sent in sentences:
+            sent = clean_leading_numbering(sent)
+            background_array.append(sent.strip().strip(string.punctuation).strip())
+        return background_array
+
+    def background_slide(self, background):
+        content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+        slide = self.prs.slides.add_slide(content_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+        title_shape = slide.shapes.title
+        title_shape.text = 'Background'
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        title_paragraph.alignment = PP_ALIGN.LEFT
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 36 pt
+
+        # Clear existing content
+        content_shape = slide.placeholders[1]
+        text_frame = content_shape.text_frame
+        text_frame.clear()
+        # ✅ Vertically center content inside the placeholder
+        text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+
+        # Add topic + indented description as two lines
+        background_item_num = len(background)
+        fontsize = 22
+        if background_item_num >= 4 and background_item_num <= 6:
+            fontsize = 20
+        elif background_item_num >7:
+            fontsize = 18
+        for idx, topic in enumerate(background, start=1):
+            p1 = text_frame.add_paragraph()
+            p1.text = f"{idx}. {topic}"
+            p1.level = 0
+            p1.font.size = Pt(fontsize)
+            p1.font.name = 'Times New Roman'
+            # p1.font.bold = True
+            p1.alignment = PP_ALIGN.LEFT
+
+        self._add_time_footnote(slide=slide)
+
+    def _problem_define_preprocess(self, problem_desc: str):
+        from collections import OrderedDict
+        def split_text_by_headers(text, headers):
+            sections = OrderedDict({header: [] for header in headers})
+            current = None
+            for line in text.strip().strip(string.punctuation).splitlines():
+                line_clean = line.strip().strip(string.punctuation).strip()
+                if len(line_clean) == 0:
+                    continue
+                # Check if line matches any of the section headers
+                matched = [h for h in headers if h.lower() == line_clean.lower()]
+                if matched:
+                    current = matched[0]
+                    continue
+                if current:
+                    cleaned_line = clean_leading_numbering(text=line_clean)
+                    cleaned_line = cleaned_line.strip().strip(string.punctuation).strip()
+                    sections[current].append(cleaned_line)
+
+            # Convert lists to joined text blocks
+            return {k: v for k, v in sections.items()}
+
+        sections = ["Scope", "Challenges", "Assumptions", "Relevance"]
+        problem_dict = {}
+        if any([_ in problem_desc for _ in sections]):
+            problem_dict = split_text_by_headers(text=problem_desc, headers=sections)
+
+        if all([len(v)==0 for k, v in problem_dict.items()]) or len(problem_dict) == 0:
+            problem_dict = {}
+            cleaned_sentences = []
+            sentences = problem_desc.strip().strip(string.punctuation).splitlines()
+            for sent in sentences:
+                cleaned_line = clean_leading_numbering(text=sent)
+                cleaned_line = cleaned_line.strip().strip(string.punctuation).strip()
+                cleaned_sentences.append(cleaned_line)
+            problem_dict['Scope'] = cleaned_sentences
+
+        return problem_dict
+
+    def problem_def_slide(self, problems):
+        sections = ["Scope", "Challenges", "Assumptions", "Relevance"]
+        scope = problems.get('Scope', [])
+        challenges = problems.get('Challenges', [])
+        assumptions = problems.get('Assumptions', [])
+        relevance = problems.get('Relevance', [])
+        for sect_name in sections:
+            section_contents = problems.get(sect_name, [])
+            if len(section_contents) == 0:
+                continue
+            content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+            slide = self.prs.slides.add_slide(content_slide_layout)
+            self._set_background_color(slide=slide)
+            self._add_logo(slide=slide)
+            title_shape = slide.shapes.title
+            if sect_name == 'Scope':
+                title_shape.text = 'Problem Definition'
+            elif sect_name in {'Challenges', 'Assumptions'}:
+                title_shape.text = 'Problem Definition - {}'.format(sect_name)
+            else:
+                title_shape.text = 'Interested Practitioners'
+            title_paragraph = title_shape.text_frame.paragraphs[0]
+            title_paragraph.alignment = PP_ALIGN.LEFT
+            for run in title_paragraph.runs:
+                run.font.bold = True
+                run.font.name = 'Times New Roman'
+                run.font.size = Pt(36)  # e.g., 36 pt
+
+            # Clear existing content
+            content_shape = slide.placeholders[1]
+            text_frame = content_shape.text_frame
+            text_frame.clear()
+            # ✅ Vertically center content inside the placeholder
+            text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+            fontsize = 20
+            for idx, topic in enumerate(section_contents, start=1):
+                p1 = text_frame.add_paragraph()
+                p1.text = f"{idx}. {topic}"
+                p1.level = 0
+                p1.font.size = Pt(fontsize)
+                p1.font.name = 'Times New Roman'
+                # p1.font.bold = True
+                p1.alignment = PP_ALIGN.LEFT
+
+            self._add_time_footnote(slide=slide)
+
+    def _objective_preprocess(self, objective: str):
+        objective_array = []
+        sentences = objective.strip().splitlines()
+        for sent in sentences:
+            sent = clean_leading_numbering(text=sent)
+            objective_array.append(sent.strip().strip(string.punctuation).strip())
+        return objective_array
+
+    def objective_slide(self, objectives):
+        content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+        slide = self.prs.slides.add_slide(content_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+        title_shape = slide.shapes.title
+        title_shape.text = 'Objectives & How'
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        title_paragraph.alignment = PP_ALIGN.LEFT
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 36 pt
+
+        # Clear existing content
+        content_shape = slide.placeholders[1]
+        text_frame = content_shape.text_frame
+        text_frame.clear()
+        # ✅ Vertically center content inside the placeholder
+        text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+
+        objective_item_num = len(objectives)
+        fontsize = 24
+        if objective_item_num >= 4 and objective_item_num <= 6:
+            fontsize = 22
+        elif objective_item_num >7:
+            fontsize = 20
+        for idx, topic in enumerate(objectives, start=1):
+            p1 = text_frame.add_paragraph()
+            p1.text = f"{idx}. {topic}"
+            p1.level = 0
+            p1.font.size = Pt(fontsize)
+            p1.font.name = 'Times New Roman'
+            # p1.font.bold = True
+            p1.alignment = PP_ALIGN.LEFT
+
+        self._add_time_footnote(slide=slide)
+
+    def _method_preprocess(self, methodology: str):
+        method_array = []
+        sentences = methodology.strip().splitlines()
+        for sent in sentences:
+            sent_trim = clean_leading_numbering(text=sent)
+            sent_trim = sent_trim.strip().strip(string.punctuation).strip()
+            method_array.append(sent_trim)
+        return method_array
+
+    def method_slide(self, methods):
+        content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+        slide = self.prs.slides.add_slide(content_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+
+        title_shape = slide.shapes.title
+        title_shape.text = 'Proposed Method'
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        title_paragraph.alignment = PP_ALIGN.LEFT
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 36 pt
+
+        # Clear existing content
+        content_shape = slide.placeholders[1]
+        text_frame = content_shape.text_frame
+        text_frame.clear()
+        # ✅ Vertically center content inside the placeholder
+        text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+
+        fontsize = 20
+        for idx, step in enumerate(methods, start=1):
+            p = text_frame.add_paragraph()
+            run1 = p.add_run()
+            run1.text = "Step {}. ".format(idx)
+            run1.font.bold = True
+            run1.font.size = Pt(fontsize)
+
+            # Second run: normal text
+            run2 = p.add_run()
+            run2.text = step
+            run2.font.bold = False
+            run2.font.size = Pt(fontsize)
+            p.font.name = 'Times New Roman'
+            p.alignment = PP_ALIGN.LEFT
+
+        self._add_time_footnote(slide=slide)
+
+    def _experiment_preprocess(self, experiment: str):
+        def split_sections_by_keywords(text: str, keyword1: str, keyword2: str) -> dict:
+            lines = text.strip().splitlines()
+            part1_lines = []
+            part2_lines = []
+            current_section = None
+            for line in lines:
+                stripped = clean_leading_numbering(line)
+                stripped = stripped.strip().strip(string.punctuation).strip()
+                if len(stripped) == 0:
+                    continue
+                if keyword1 in stripped:
+                    current_section = keyword1
+                    continue
+                elif keyword2 in stripped:
+                    current_section = keyword2
+                    continue
+
+                if current_section == keyword1:
+                    tokens = stripped.split(':')
+                    key = tokens[0].strip().strip(string.punctuation).strip()
+                    if len(tokens) > 1:
+                        parse_stripped = key + ": " + ':'.join(tokens[1:]).strip().strip(string.punctuation).strip()
+                    else:
+                        parse_stripped = key
+                    part1_lines.append(parse_stripped)
+                elif current_section == keyword2:
+                    tokens = stripped.split(':')
+                    key = tokens[0].strip().strip(string.punctuation).strip()
+                    if len(tokens) > 1:
+                        parse_stripped = (key, ':'.join(tokens[1:]))
+                    else:
+                        parse_stripped = (key, '')
+                    part2_lines.append(parse_stripped)
+            return {
+                keyword1: part1_lines,
+                keyword2: part2_lines
+            }
+
+        experiment_dict = {}
+        sentences = experiment.strip().splitlines()
+        evidence_keyword = 'Evidence Summary'
+        exp_summary_keyword = 'Experimental Summary'
+        if (evidence_keyword in experiment) and (exp_summary_keyword in experiment):
+            experiment_dict = split_sections_by_keywords(text=experiment, keyword1=evidence_keyword, keyword2=exp_summary_keyword)
+        else:
+            experiment_array = []
+            for sent in sentences:
+                sent = clean_leading_numbering(sent)
+                sent = sent.strip().strip(string.punctuation).strip()
+                experiment_array.append(sent)
+            experiment_dict[exp_summary_keyword] = experiment_array
+        return experiment_dict
+
+    def experiment_slide(self, experiments):
+        evidence_keyword = 'Evidence Summary'
+        exp_summary_keyword = 'Experimental Summary'
+        if len(experiments) == 1:
+            experiments_part1 = experiments[exp_summary_keyword]
+            experiments_part2 = []
+        else:
+            assert len(experiments) == 2
+            experiments_part1 = experiments[exp_summary_keyword]
+            experiments_part2 = experiments[evidence_keyword]
+
+        content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+        slide = self.prs.slides.add_slide(content_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+        title_shape = slide.shapes.title
+        title_shape.text = 'Experimental Study'
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        title_paragraph.alignment = PP_ALIGN.LEFT
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 36 pt
+
+        # Clear existing content
+        content_shape = slide.placeholders[1]
+        text_frame = content_shape.text_frame
+        text_frame.clear()
+        # ✅ Vertically center content inside the placeholder
+        text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+
+        fontsize = 20
+        if len(experiments_part2) == 0:
+            for idx, sent in enumerate(experiments_part1, start=1):
+                p1 = text_frame.add_paragraph()
+                p1.text = f"{idx}. {sent}"
+                p1.level = 0
+                p1.font.size = Pt(fontsize)
+                p1.font.name = 'Times New Roman'
+                p1.font.bold = True
+                p1.alignment = PP_ALIGN.LEFT
+        else:
+            for idx, step in enumerate(experiments_part1, start=1):
+                key, value = step
+                if len(value) == 0:
+                    continue
+                p = text_frame.add_paragraph()
+                run1 = p.add_run()
+                run1.text = key
+                run1.font.bold = True
+                run1.font.size = Pt(fontsize)
+
+                # Second run: normal text
+                run2 = p.add_run()
+                run2.text = value
+                run2.font.bold = False
+                run2.font.size = Pt(fontsize)
+                p.font.name = 'Times New Roman'
+                p.alignment = PP_ALIGN.LEFT
+
+        self._add_time_footnote(slide=slide)
+
+        ###experimental study in multiple pages
+        if len(experiments_part2) > 0:
+            content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+            slide_2 = self.prs.slides.add_slide(content_slide_layout)
+            self._set_background_color(slide=slide_2)
+            self._add_logo(slide=slide_2)
+            title_shape = slide_2.shapes.title
+            title_shape.text = 'Experimental Study (Summary)'
+            title_paragraph = title_shape.text_frame.paragraphs[0]
+            title_paragraph.alignment = PP_ALIGN.LEFT
+            for run in title_paragraph.runs:
+                run.font.bold = True
+                run.font.name = 'Times New Roman'
+                run.font.size = Pt(36)  # e.g., 36 pt
+
+            # Clear existing content
+            content_shape = slide_2.placeholders[1]
+            text_frame = content_shape.text_frame
+            text_frame.clear()
+            # ✅ Vertically center content inside the placeholder
+            text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+            self._add_time_footnote(slide=slide_2)
+            for idx, sent in enumerate(experiments_part2, start=1):
+                p1 = text_frame.add_paragraph()
+                p1.text = f"{idx}. {sent}"
+                p1.level = 0
+                p1.font.size = Pt(fontsize)
+                p1.font.name = 'Times New Roman'
+                p1.alignment = PP_ALIGN.LEFT
+
+    def _conclusion_preprocess(self, conclusion: str):
+        conclusion_dict = {}
+        sentences = conclusion.strip().splitlines()
+        for sent in sentences:
+            trim_sent = sent.strip().strip(string.punctuation).strip()
+            trim_sent = clean_leading_numbering(text=trim_sent)
+            if len(trim_sent) == 0 or trim_sent.lower().startswith('conclusion'):
+                continue
+            else:
+                tokens = trim_sent.split(':')
+                key = tokens[0].strip().strip(string.punctuation).strip()
+                if len(tokens) == 1:
+                    conclusion_dict[key] = ''
+                else:
+                    value = ':'.join(tokens[1:]).strip().strip(string.punctuation).strip()
+                    conclusion_dict[key] = value
+        return conclusion_dict
+
+    def conclusion_slide(self, conclusion):
+        content_slide_layout = self.prs.slide_layouts[1]  # title and Content Slide Layout
+        slide = self.prs.slides.add_slide(content_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+        title_shape = slide.shapes.title
+        title_shape.text = 'Conclusions & Future Work'
+        title_paragraph = title_shape.text_frame.paragraphs[0]
+        title_paragraph.alignment = PP_ALIGN.LEFT
+        for run in title_paragraph.runs:
+            run.font.bold = True
+            run.font.name = 'Times New Roman'
+            run.font.size = Pt(36)  # e.g., 36 pt
+
+        # Clear existing content
+        content_shape = slide.placeholders[1]
+        text_frame = content_shape.text_frame
+        text_frame.clear()
+        # ✅ Vertically center content inside the placeholder
+        text_frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+
+        # Add topic
+        for topic, desc in conclusion.items():
+            if len(desc) == 0:
+                continue
+            p1 = text_frame.add_paragraph()
+            p1.text = topic
+            p1.level = 0
+            p1.font.size = Pt(20)
+            p1.font.name = 'Times New Roman'
+            p1.font.bold = True
+            p1.alignment = PP_ALIGN.LEFT
+
+            # Line 2: description (indented)
+            p2 = text_frame.add_paragraph()
+            p2.text = desc
+            p2.level = 1  # Indented bullet
+            p2.font.size = Pt(16)
+            p2.font.italic = True
+            p2.font.name = 'Times New Roman'
+            p2.alignment = PP_ALIGN.LEFT
+
+        self._add_time_footnote(slide=slide)
+
+    def build_slides(self, slide_dict: dict, authors: str = 'Author here'):
+        title = slide_dict.get('Title', '')
+        title = self._title_preprocess(title=title)
+        self.title_slide(title=title, authors=authors)
+
+        outline = slide_dict.get('Outline', {})
+        outline = self._outline_preprocess_(outline=outline)
+        assert len(outline) > 0, 'No outline detected!!!'
+        self.outline_slide(outline=outline)
+
+        background = slide_dict.get('Background', '')
+        if background:
+            background = self._background_preprocess(background=background)
+            self.background_slide(background=background)
+
+        problem_definition = slide_dict.get('Research problem', '')
+        # print('problem_definition', problem_definition)
+        if problem_definition:
+            problems = self._problem_define_preprocess(problem_desc=problem_definition)
+            # print('problems', problems)
+            self.problem_def_slide(problems=problems)
+
+        objectives = slide_dict.get('Objectives', '')
+        if objectives:
+            objectives = self._objective_preprocess(objective=objectives)
+            self.objective_slide(objectives=objectives)
+
+        methodology = slide_dict.get('Methodology', '')
+        if methodology:
+            methodology = self._method_preprocess(methodology=methodology)
+            # print('Method', methodology)
+            self.method_slide(methods=methodology)
+
+        experimental_study = slide_dict.get('Results', '')
+        if experimental_study:
+            experiments = self._experiment_preprocess(experiment=experimental_study)
+            # print('experiments', experiments)
+            self.experiment_slide(experiments=experiments)
+
+        conclusion = slide_dict.get('Conclusions', '')
+        if conclusion:
+            conclusion = self._conclusion_preprocess(conclusion=conclusion)
+            self.conclusion_slide(conclusion=conclusion)
+
+        self.qa_slides()
+        print('Done!!')
+
+    def qa_slides(self):
+        # Add a blank slide (usually layout 6 is blank)
+        blank_slide_layout = self.prs.slide_layouts[6]
+        slide = self.prs.slides.add_slide(blank_slide_layout)
+        self._set_background_color(slide=slide)
+        self._add_logo(slide=slide)
+
+        # Add a textbox in the center
+        left = Inches(2)
+        top = Inches(2.5)
+        width = Inches(6)
+        height = Inches(2)
+
+        textbox = slide.shapes.add_textbox(left, top, width, height)
+        text_frame = textbox.text_frame
+        text_frame.clear()
+
+        # Add "Thank you"
+        p1 = text_frame.add_paragraph()
+        p1.text = "Thank you!"
+        p1.font.size = Pt(44)
+        p1.font.bold = True
+        p1.alignment = PP_ALIGN.CENTER
+
+        # Add "Q & A"
+        p2 = text_frame.add_paragraph()
+        p2.text = "\nQ & A"
+        p2.font.size = Pt(36)
+        p2.alignment = PP_ALIGN.CENTER
+
+        self._add_time_footnote(slide=slide)
+
+    def save(self, file_name='slides.pptx'):
+        self.prs.save(file_name)

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+pdf4llm
+openai
+python-dotenv
+python-pptx

sambaAPI.py

@@ -0,0 +1,64 @@
+from dotenv import load_dotenv
+from openai import OpenAI
+import os
+
+MODEL_ALIAS = {'llama3_8b': 'Meta-Llama-3.1-8B-Instruct',
+                'llama3_70b': 'Meta-Llama-3.1-70B-Instruct',
+                'llama3_3_70b': 'Meta-Llama-3.3-70B-Instruct',
+                'llama3_405b': 'Meta-Llama-3.1-405B-Instruct',
+                'llama3_1b': "Meta-Llama-3.2-1B-Instruct",
+                'llama3_3b': "Meta-Llama-3.2-3B-Instruct"}
+
+load_dotenv()
+
+client = OpenAI(
+    base_url="https://api.sambanova.ai/v1",  # the endpoint IP running on vLLM cloud.sambanova.ai, https://api.sambanova.ai. fast-api.snova.ai
+    api_key=os.environ.get("SAMBA_API_KEY"),
+)
+
+
+def call_llama(system_prompt, prompt, model="Meta-Llama-3.1-8B-Instruct", **kwargs):
+    """
+    kwargs: 
+    temperature =  0.1,
+    top_p = 0.1
+    max_tokens = 50
+    """
+    try:
+      completion = client.chat.completions.create(
+        model=model,
+        messages=[
+          {"role": "system", "content": system_prompt},
+          {"role": "user", "content": prompt}
+        ],
+        stream=True,
+        **kwargs,
+      )
+      response = ""
+      for chunk in completion:
+          response += chunk.choices[0].delta.content or ""
+      return response
+    except Exception as e:
+      print('API Error = {}'.format(e))
+      return ""
+
+def call_llama_chat(messages, model="Meta-Llama-3.1-8B-Instruct", **kwargs):
+    """
+    kwargs: 
+    temperature =  0.1,
+    top_p = 0.1
+    """
+    try:
+      completion = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        stream=True,
+        **kwargs,
+      )
+      response = ""
+      for chunk in completion:
+          response += chunk.choices[0].delta.content or ""
+      return response
+    except Exception as e:
+      print('API Error = {}'.format(e))
+      return ""

utils.py

@@ -0,0 +1,39 @@
+import json
+from paper2slides import Paper2Slides, PaperReader
+import os
+
+def read_json(file_path: str):
+    try:
+        with open(file_path, "r") as json_file:
+            data = json.load(json_file)
+        return data
+    except FileNotFoundError:
+        print(f"Error: The file '{file_path}' was not found.")
+        return None
+    except json.JSONDecodeError:
+        print(f"Error: The file '{file_path}' is not a valid JSON.")
+        return None
+
+
+def get_file_name(full_path: str):
+    file_name = os.path.splitext(os.path.basename(full_path))[0]
+    return file_name
+
+
+def run_pdf2text(paper_pdf_path: str, save_json_name: str):
+    reader = PaperReader()
+    paper_content = reader.run(paper_file_name=paper_pdf_path)
+    # Save the dictionary as a JSON file
+    with open(save_json_name, 'w') as json_file:
+        json.dump(paper_content, json_file, indent=4)
+    return paper_content
+
+
+def run_paper2slides(paper_json_name: str, model='llama3_70b', temprature=0.2, logo_path='logo.png', save_file_name:str='slides.pptx'):
+    paper_content = read_json(paper_json_name)
+    paper2slides = Paper2Slides(paper_contents=paper_content, model=model, temprature=temprature)
+    slides = paper2slides.generate_slides(verbose=False, revision=False)
+    with open('slides.json', 'w') as f:
+        json.dump(slides, f, indent=4)  # indent=4 makes it pretty-printed
+    assert isinstance(slides, dict)
+    return paper2slides.save_to_slides(slides=slides, logo_path=logo_path, file_name=save_file_name)