init commit

.gitignore

@@ -0,0 +1,2 @@
+.env
+__pycache__

classes/edge_tts_generator.py

@@ -0,0 +1,84 @@
+# classes/edge_tts_generator.py
+
+import asyncio
+import pickle
+import re
+from tqdm import tqdm
+import ast
+import edge_tts
+
+class EdgeTTSGenerator:
+    """
+    A class to generate podcast-style audio from a transcript using edge-tts.
+    """
+    def __init__(self, transcript_file_path, output_audio_path):
+        """
+        Initialize the TTS generator with the path to the rewritten transcript file.
+        
+        Args:
+            transcript_file_path (str): Path to the file containing the rewritten transcript.
+            output_audio_path (str): Path to save the generated audio file.
+        """
+        self.transcript_file_path = transcript_file_path
+        self.output_audio_path = output_audio_path
+
+        # Speaker descriptions for edge-tts voices
+        self.speaker1_voice = "en-US-AriaNeural"
+        self.speaker2_voice = "en-US-GuyNeural"
+
+    def load_transcript(self):
+        """
+        Loads the rewritten transcript from the specified file.
+        
+        Returns:
+            list: The content of the transcript as a list of tuples (speaker, text).
+        """
+        with open(self.transcript_file_path, 'rb') as f:
+            return ast.literal_eval(pickle.load(f))
+
+    async def generate_audio_segment(self, text, voice_name):
+        """
+        Generate audio for a given text using edge-tts.
+        
+        Args:
+            text (str): Text to be synthesized.
+            voice_name (str): The voice name to use for TTS.
+        
+        Returns:
+            bytes: Generated audio data.
+        """
+        communicator = edge_tts.Communicate(text, voice_name)
+        audio_bytes = b""
+        async for chunk in communicator.stream():
+            if "data" in chunk:  # Check if 'data' exists in chunk
+                audio_bytes += chunk["data"]  # Concatenate only the audio data
+        return audio_bytes
+
+    def save_audio(self, audio_data):
+        """
+        Save the combined audio data to an output file.
+        
+        Args:
+            audio_data (list): List of bytes containing the audio data for each segment.
+        """
+        combined_audio = b"".join(audio_data)
+        with open(self.output_audio_path, "wb") as f:
+            f.write(combined_audio)
+
+    async def generate_audio(self):
+        """
+        Converts the transcript into audio and saves it to a file.
+        
+        Returns:
+            str: Path to the saved audio file.
+        """
+        transcript = self.load_transcript()
+        audio_data = []
+
+        for speaker, text in tqdm(transcript, desc="Generating podcast segments", unit="segment"):
+            voice = self.speaker1_voice if speaker == "Speaker 1" else self.speaker2_voice
+            segment_audio = await self.generate_audio_segment(text, voice)
+            audio_data.append(segment_audio)
+
+        self.save_audio(audio_data)
+        return self.output_audio_path

classes/pdf_text_extractor.py

@@ -0,0 +1,145 @@
+# classes/pdf_text_extractor.py
+
+import os
+import openai
+from PyPDF2 import PdfReader
+import re
+from tqdm import tqdm
+
+from prompts import PDF_SYSTEM_PROMPT
+from config import llm_configs
+import time
+
+class PDFTextExtractor:
+    """
+    A class to handle PDF text extraction and preprocessing for podcast preparation.
+    """
+    def __init__(self, pdf_path, output_path, model_name="llama3-8b-8192", llm_config=None, max_chars=100000, chunk_size=1000):
+        """
+        Initialize the PDFTextExtractor with paths and model details.
+        
+        Args:
+            pdf_path (str): Path to the PDF file.
+            output_path (str): Path to save the cleaned text file.
+            model_name (str): Name of the model to use for text processing.
+            llm_config (dict): Configuration for the LLM.
+            max_chars (int): Maximum number of characters to process from the PDF.
+            chunk_size (int): Size of text chunks to process at a time.
+        """
+        self.pdf_path = pdf_path
+        self.output_path = output_path
+        self.max_chars = max_chars
+        self.chunk_size = chunk_size
+        self.model_name = model_name
+        self.llm_config = llm_config or llm_configs.get(model_name)
+        
+        if self.llm_config is None:
+            raise ValueError(f"Model configuration for {model_name} not found in llm_configs.")
+        
+        # System prompt for text processing
+        self.system_prompt = PDF_SYSTEM_PROMPT
+    
+    def create_client(self):
+        openai.api_key = self.llm_config["api_key"]
+        openai.api_base = self.llm_config["base_url"]
+        return openai
+    
+    def validate_pdf(self):
+        """Check if the file exists and is a valid PDF."""
+        if not os.path.exists(self.pdf_path):
+            print(f"Error: File not found at path: {self.pdf_path}")
+            return False
+        if not self.pdf_path.lower().endswith('.pdf'):
+            print("Error: File is not a PDF")
+            return False
+        return True
+
+    def extract_text(self):
+        """Extract text from the PDF, limited by max_chars."""
+        if not self.validate_pdf():
+            return None
+        
+        with open(self.pdf_path, 'rb') as file:
+            pdf_reader = PdfReader(file)
+            num_pages = len(pdf_reader.pages)
+            print(f"Processing PDF with {num_pages} pages...")
+            
+            extracted_text = []
+            total_chars = 0
+            
+            for page_num in range(num_pages):
+                page = pdf_reader.pages[page_num]
+                text = page.extract_text() or ""
+                
+                if total_chars + len(text) > self.max_chars:
+                    remaining_chars = self.max_chars - total_chars
+                    extracted_text.append(text[:remaining_chars])
+                    print(f"Reached {self.max_chars} character limit at page {page_num + 1}")
+                    break
+                
+                extracted_text.append(text)
+                total_chars += len(text)
+                print(f"Processed page {page_num + 1}/{num_pages}")
+            
+            final_text = '\n'.join(extracted_text)
+            print(f"Extraction complete! Total characters: {len(final_text)}")
+            return final_text
+
+    def create_word_bounded_chunks(self, text):
+        """Split text into chunks around the target size."""
+        words = text.split()
+        chunks = []
+        current_chunk = []
+        current_length = 0
+        
+        for word in words:
+            word_length = len(word) + 1  # +1 for the space
+            if current_length + word_length > self.chunk_size and current_chunk:
+                chunks.append(' '.join(current_chunk))
+                current_chunk = [word]
+                current_length = word_length
+            else:
+                current_chunk.append(word)
+                current_length += word_length
+        
+        if current_chunk:
+            chunks.append(' '.join(current_chunk))
+        
+        return chunks
+
+    def process_chunk(self, text_chunk):
+        """Process a text chunk with the model and return the cleaned text."""
+        conversation = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": text_chunk}
+        ]
+        client = self.create_client()
+
+        response = client.ChatCompletion.create(
+            model=self.model_name,
+            messages=conversation,
+        )
+        
+        processed_text = response.choices[0].message.content
+        
+        return processed_text
+
+    def clean_and_save_text(self):
+        """Extract, clean, and save processed text to a file."""
+        extracted_text = self.extract_text()
+        if not extracted_text:
+            return None
+        
+        chunks = self.create_word_bounded_chunks(extracted_text)
+        processed_text = ""
+        
+        with open(self.output_path, 'w', encoding='utf-8') as out_file:
+            for chunk_num, chunk in enumerate(tqdm(chunks, desc="Processing chunks")):
+                processed_chunk = self.process_chunk(chunk)
+                processed_text += processed_chunk + "\n"
+                out_file.write(processed_chunk + "\n")
+                out_file.flush()
+                time.sleep(3)  # To avoid rate limiting
+        
+        print(f"\nExtracted and cleaned text has been saved to {self.output_path}")
+        return self.output_path

classes/transcript_processor.py

@@ -0,0 +1,129 @@
+# classes/transcript_processor.py
+
+import os
+import openai
+import pickle
+import re
+
+from prompts import TRANSCRIPT_PROMPT, REWRITE_PROMPT
+from config import llm_configs
+
+class TranscriptProcessor:
+    """
+    A class to generate and rewrite podcast-style transcripts using a specified language model.
+    """
+
+    def __init__(self, text_file_path, transcript_output_path, tts_output_path, model_name="llama3-70b-8192", llm_config=None):
+        """
+        Initialize with the path to the cleaned text file and the model name.
+        
+        Args:
+            text_file_path (str): Path to the file containing cleaned PDF text.
+            transcript_output_path (str): Path to save the generated transcript.
+            tts_output_path (str): Path to save the rewritten transcript for TTS.
+            model_name (str): Name of the language model to use.
+            llm_config (dict): Configuration for the LLM.
+        """
+        self.text_file_path = text_file_path
+        self.transcript_output_path = transcript_output_path
+        self.tts_output_path = tts_output_path
+        self.model_name = model_name
+        self.llm_config = llm_config or llm_configs.get(model_name)
+
+        if self.llm_config is None:
+            raise ValueError(f"Model configuration for {model_name} not found in llm_configs.")
+
+        self.transcript_prompt = TRANSCRIPT_PROMPT
+        self.rewrite_prompt = REWRITE_PROMPT
+
+    def create_client(self):
+        openai.api_key = self.llm_config["api_key"]
+        openai.api_base = self.llm_config["base_url"]
+        return openai
+
+    def load_text(self):
+        """
+        Reads the cleaned text file and returns its content.
+        
+        Returns:
+            str: Content of the cleaned text file.
+        """
+        encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+        for encoding in encodings:
+            try:
+                with open(self.text_file_path, 'r', encoding=encoding) as file:
+                    content = file.read()
+                print(f"Successfully read file using {encoding} encoding.")
+                return content
+            except (UnicodeDecodeError, FileNotFoundError):
+                continue
+        print(f"Error: Could not decode file '{self.text_file_path}' with any common encoding.")
+        return None
+
+    def generate_transcript(self):
+        """
+        Generates a podcast-style transcript and saves it as a pickled file.
+        
+        Returns:
+            str: Path to the file where the transcript is saved.
+        """
+        input_text = self.load_text()
+        if input_text is None:
+            return None
+        
+        messages = [
+            {"role": "system", "content": self.transcript_prompt},
+            {"role": "user", "content": input_text}
+        ]
+        
+        client = self.create_client()
+
+        response = client.ChatCompletion.create(
+            model=self.model_name,
+            messages=messages,
+        )
+
+        transcript = response.choices[0].message.content
+
+        # Save the transcript as a pickle file
+        with open(self.transcript_output_path, 'wb') as f:
+            pickle.dump(transcript, f)
+        
+        return self.transcript_output_path
+        
+    def extract_tuple(self, text):
+        match = re.search(r'\[.*\]', text, re.DOTALL) 
+        if match:
+            return match.group(0)
+        return None
+
+    def rewrite_transcript(self):
+        """
+        Refines the transcript for TTS, adding expressive elements and saving as a list of tuples.
+        
+        Returns:
+            str: Path to the file where the TTS-ready transcript is saved.
+        """
+        # Load the initial generated transcript
+        with open(self.transcript_output_path, 'rb') as file:
+            input_transcript = pickle.load(file)
+        
+        messages = [
+            {"role": "system", "content": self.rewrite_prompt},
+            {"role": "user", "content": input_transcript}
+        ]
+        
+        client = self.create_client()
+
+        response = client.ChatCompletion.create(
+            model=self.model_name,
+            messages=messages,
+        )
+        
+        rewritten_transcript = self.extract_tuple(response.choices[0].message.content)
+        
+        # Save the rewritten transcript as a pickle file
+        with open(self.tts_output_path, 'wb') as f:
+            pickle.dump(rewritten_transcript, f)
+        
+        return self.tts_output_path

config.py

@@ -0,0 +1,54 @@
+# config.py
+
+import os
+
+llm_configs = {
+    # Mistral Models
+    "mistral-large-latest": {
+        "base_url": "https://api.mistral.ai/v1",
+        "api_key": os.environ.get("MISTRAL_API_KEY"),
+        "provider": "mistral",
+        "version": "mistral-large-2407"
+    },
+    "mistral-small-latest": {
+        "base_url": "https://api.mistral.ai/v1", 
+        "api_key": os.environ.get("MISTRAL_API_KEY"),
+        "provider": "mistral",
+        "version": "mistral-small-2409"
+    },
+    "open-mistral-nemo": {
+        "base_url": "https://api.mistral.ai/v1",
+        "api_key": os.environ.get("MISTRAL_API_KEY"), 
+        "provider": "mistral",
+        "version": "open-mistral-nemo-2407"
+    },
+
+    # Groq Models
+    "llama-3.1-70b-versatile": {
+        "base_url": "https://api.groq.com/openai/v1",
+        "api_key": os.environ.get("GROQ_API_KEY"),
+        "provider": "groq"
+    },
+    "mixtral-8x7b-32768": {
+        "base_url": "https://api.groq.com/openai/v1",
+        "api_key": os.environ.get("GROQ_API_KEY"),
+        "provider": "groq"
+    },
+    "llama3-70b-8192": {
+        "base_url": "https://api.groq.com/openai/v1",
+        "api_key": os.environ.get("GROQ_API_KEY"),
+        "provider": "groq"
+    },
+
+    # Grok Models  
+    "grok-beta": {
+        "base_url": "https://api.x.ai/v1",
+        "api_key": os.environ.get("GROK_API_KEY"),
+        "provider": "grok",
+        "context_window": 131072,
+        "pricing": {
+            "input": 5,     # per 131,072 tokens
+            "output": 15    # per 131,072 tokens
+        }
+    }
+}

main.py

@@ -0,0 +1,173 @@
+#main.py
+
+import gradio as gr
+import os
+import shutil
+import asyncio
+import tempfile
+import pickle
+import traceback  # Import traceback for detailed error messages
+
+from classes.pdf_text_extractor import PDFTextExtractor
+from classes.transcript_processor import TranscriptProcessor
+from classes.edge_tts_generator import EdgeTTSGenerator
+
+from config import llm_configs
+
+def create_temp_session_directory():
+    return tempfile.mkdtemp()
+
+def process_pdf_to_podcast(pdf_file, model_name, max_chars=100000, chunk_size=1000):
+    try:
+        session_dir = create_temp_session_directory()
+        
+        pdf_path = os.path.join(session_dir, "uploaded_pdf.pdf")
+        clean_text_path = os.path.join(session_dir, "clean_text.txt")
+        transcript_path = os.path.join(session_dir, "data.pkl")
+        tts_ready_path = os.path.join(session_dir, "podcast_ready_data.pkl")
+        audio_output_path = os.path.join(session_dir, "final_podcast_audio.mp3")
+        
+        shutil.copy(pdf_file.name, pdf_path)
+        
+        llm_config = llm_configs.get(model_name)
+        if llm_config is None:
+            return f"Model {model_name} not found in configuration.", None, None, None, None
+
+        extractor = PDFTextExtractor(pdf_path, clean_text_path, model_name=model_name, llm_config=llm_config, max_chars=max_chars, chunk_size=chunk_size)
+        clean_text_path = extractor.clean_and_save_text()
+        
+        with open(clean_text_path, 'r', encoding='utf-8') as file:
+            text_preview = file.read(500)
+        
+        processor = TranscriptProcessor(clean_text_path, transcript_path, tts_ready_path, model_name=model_name, llm_config=llm_config)
+        transcript_path = processor.generate_transcript()
+        
+        with open(transcript_path, 'rb') as f:
+            transcript_preview = pickle.load(f)
+        
+        tts_ready_path = processor.rewrite_transcript()
+        
+        with open(tts_ready_path, 'rb') as f:
+            tts_ready_preview = pickle.load(f)
+        
+        return (
+            "Steps 1-3 completed successfully. Preview and adjust the rewritten transcript if needed.", 
+            text_preview,
+            transcript_preview,
+            tts_ready_preview,
+            session_dir 
+        )
+    except Exception as e:
+        error_message = f"An error occurred during processing: {str(e)}"
+        # Optionally, include traceback for debugging (comment out in production)
+        # error_message += "\n" + traceback.format_exc()
+        return error_message, None, None, None, None
+
+def generate_audio_from_modified_text(tts_ready_text, session_dir):
+    try:
+        if not session_dir:
+            session_dir = create_temp_session_directory()
+        
+        tts_ready_path = os.path.join(session_dir, "podcast_ready_data.pkl")
+        audio_output_path = os.path.join(session_dir, "final_podcast_audio.mp3")
+        
+        with open(tts_ready_path, 'wb') as f:
+            pickle.dump(tts_ready_text, f)
+        
+        tts_gen = EdgeTTSGenerator(tts_ready_path, audio_output_path)
+        audio_path = asyncio.run(tts_gen.generate_audio())
+        return "Step 4 completed successfully. Audio saved.", audio_path
+    except Exception as e:
+        error_message = f"An error occurred during audio generation: {str(e)}"
+        # Optionally, include traceback for debugging (comment out in production)
+        # error_message += "\n" + traceback.format_exc()
+        return error_message, None
+
+# Gradio Interface with Informative Descriptions and Multi-page Layout
+custom_theme = gr.themes.Default(
+    primary_hue="purple",
+    secondary_hue="purple",
+).set(
+    button_primary_background_fill="#6A0DAD",  # Deep purple for primary button
+    button_primary_background_fill_hover="#8B5FBF",  # Lighter purple on hover
+    button_primary_border_color="#6A0DAD",  # Deep purple for border color
+    button_primary_border_color_hover="#8B5FBF",  # Lighter purple on hover
+    checkbox_background_color="#4B0082",  # Indigo for checkboxes
+    checkbox_background_color_hover="#7D3F98",  # Slightly lighter purple on hover
+)
+
+with gr.Blocks(theme=custom_theme) as app:
+    gr.Markdown("# AI Research Companion - Transforming Papers into Podcasts")
+    gr.Markdown("Harnessing AI to make research more accessible and effortless, by converting complex papers into engaging audio experiences.")
+    # Page 1: Project Overview and PDF Upload
+    with gr.Tab("Overview and Upload"):
+        gr.Markdown("""
+
+        ## Project Background
+        This project was initially implemented during the Smart India Hackathon (SIH) to address a real struggle I faced: managing the overwhelming flow of research papers and effectively understanding each one. The intensity of this process highlighted how valuable an AI-powered solution could be, not just for me but for others facing similar challenges in academia. By using large language models, this tool aims to make academic material more accessible and manageable, converting dense research into an audio format that’s easier to consume. And with the power of AI, I hope that this tool can transform the way we learn and engage with academic content.
+
+        Development is still ongoing, with plans to integrate web search capabilities and explore additional TTS engines to enhance usability. Special thanks to [yasserrmd](https://huggingface.co/spaces/yasserrmd/NotebookLlama) for inspiring the structured prompts that drive this project forward.
+                    
+        This AI Research Companion is crafted to bridge the gap between research and accessibility, turning in-depth research papers into audio podcasts for easier, on-the-go learning.
+        This page allows users to upload their research papers in PDF format to initiate the conversion process.
+        """)
+        
+        with gr.Row():
+            pdf_input = gr.File(label="Upload PDF", type='filepath')
+            text_model = gr.Dropdown(
+                label="Select Text Model",
+                choices=list(llm_configs.keys()),
+                value="llama3-70b-8192"
+            )
+            max_chars = gr.Number(label="Max Characters to Process", value=100000, maximum=100000)
+            chunk_size = gr.Number(label="Chunk Size", value=1000)
+            run_all_button = gr.Button("Process Document")
+            output_status = gr.Textbox(label="Status", interactive=False, lines=5)
+    # Page 2: Preview Extracted Text
+    with gr.Tab("Text Extraction"):
+        gr.Markdown("""
+        ## Text Extraction
+        At this stage, your research paper’s content is carefully extracted, setting the foundation for its transformation into an audio-friendly format.
+        This extracted text will be used to generate a transcript and prepare it for text-to-speech (TTS) conversion.
+        """)
+        extracted_text_preview = gr.Textbox(label="Extracted Text Preview (First 500 Characters)", interactive=False, lines=10)
+    # Page 3: Generate Transcript
+    with gr.Tab("Transcript Generation"):
+        gr.Markdown("""
+        ## Transcript Generation
+        Here, the extracted text is structured into a clean, readable transcript, perfect for creating clear audio and adjusting any finer details.
+        This transcript can be modified before proceeding to the next step for audio generation. And fix any other errors left by the large language model.
+        """)
+        transcript_preview = gr.Textbox(label="Generated Transcript Preview", interactive=False, lines=10)
+    # Page 4: Edit TTS-ready Transcript
+    with gr.Tab("Edit Transcript for TTS"):
+        gr.Markdown("""
+        ## Edit Transcript for TTS
+       This refined transcript is ready for a final polish, ensuring it’s clear and precise before creating an audio experience.
+        Users can make final adjustments to the text here to ensure accuracy and coherence before audio generation.
+        """)
+        tts_ready_preview = gr.Textbox(label="Editable Rewritten Transcript for TTS", interactive=True, lines=10)
+        generate_audio_button = gr.Button("Generate Audio from Edited Transcript")
+    # Page 5: Listen to Generated Podcast Audio
+    with gr.Tab("Audio Output"):
+        gr.Markdown("""
+        ## Audio Output
+       Your transformed audio is now ready! Listen to your research in a podcast-like format, perfect for accessible and engaging learning on-the-go.
+        """)
+        final_audio_output = gr.Audio(label="Generated Podcast Audio")
+    
+    session_dir = gr.State()
+    # Execute Steps 1-3: Upload, Process, Extract
+    run_all_button.click(
+        process_pdf_to_podcast, 
+        inputs=[pdf_input, text_model, max_chars, chunk_size], 
+        outputs=[output_status, extracted_text_preview, transcript_preview, tts_ready_preview, session_dir]
+    )
+    # Step 4: Generate Audio from Edited Transcript
+    generate_audio_button.click(
+        generate_audio_from_modified_text, 
+        inputs=[tts_ready_preview, session_dir],
+        outputs=[output_status, final_audio_output]
+    )
+
+app.launch()

prompts.py

@@ -0,0 +1,71 @@
+# prompts.py
+PDF_SYSTEM_PROMPT = """
+As a highly skilled text pre-processor, your job is to take raw data from a PDF and transform it into a polished format that a podcast writer can easily utilize.
+
+The raw data may include jumbled line breaks, LaTeX equations, and irrelevant filler content. Your objective is to refine this content, removing anything that doesn’t add value to a podcast transcript.
+
+Remember, the podcast could cover any topic, so keep an open mind about what might be unnecessary.
+
+Be thoughtful and creative in your editing process.
+
+IMPORTANT: DO NOT START WITH A SUMMARY; YOUR FOCUS IS SOLELY ON CLEANING UP AND REWRITING THE TEXT AS NEEDED.
+
+Be proactive in cutting out unnecessary details. You will receive text in segments and should return the cleaned version each time.
+
+PLEASE AVOID MARKDOWN FORMATTING OR SPECIAL CHARACTERS THAT MIGHT DISTORT THE TEXT.
+
+ALWAYS begin your response with the cleaned text, without any introductory comments or acknowledgments.
+Here is the text:"""
+
+TRANSCRIPT_PROMPT = """
+You are an accomplished podcast writer who has worked with top hosts like Joe Rogan, Lex Fridman, Ben Shapiro, and Tim Ferriss.
+
+Imagine that you have been the ghostwriter for all their conversations, seamlessly blending their thoughts into engaging dialogues.
+
+Your writing has won numerous awards for its captivating style.
+
+Make sure the conversation stays lively and engaging. While speakers may occasionally wander off-topic, they should always return to the main discussion.
+
+**Speaker 1**: Takes the lead in the conversation, sharing insightful anecdotes and analogies. They are an engaging educator who captivates listeners with compelling stories.
+
+**Speaker 2**: Keeps the dialogue focused by asking follow-up questions. They express genuine curiosity, showing excitement or confusion as they seek clarity. Their questions should lead to fascinating real-world examples.
+
+Encourage Speaker 2 to introduce interesting or surprising tangents during their inquiries.
+
+Craft this as if it were a real podcast episode, capturing every nuance in rich detail. Start with an engaging introduction that draws listeners in with an enticing hook.
+
+ALWAYS START YOUR RESPONSE DIRECTLY WITH SPEAKER 1:
+DO NOT SEPARATELY LIST EPISODE TITLES; LET SPEAKER 1 NAME IT IN THEIR DIALOGUE.
+DO NOT INCLUDE CHAPTER TITLES.
+ONLY RETURN THE DIALOGUES.
+"""
+
+REWRITE_PROMPT = """
+You are a celebrated Oscar-winning screenwriter known for your collaborations with award-winning podcasters.
+
+Your task is to enhance the podcast transcript provided below for an AI Text-To-Speech Pipeline. The initial draft was created by a basic AI and needs your artistic touch to elevate it.
+
+Make it as engaging as possible, considering that Speaker 1 and Speaker 2 will be represented by different voice engines.
+
+**Speaker 1**: Guides the conversation with insightful explanations and captivating stories.
+**Speaker 2**: Keeps the dialogue on track by asking thoughtful follow-up questions and expressing excitement or confusion as needed.
+
+Ensure that Speaker 2's tangents are both imaginative and engaging.
+
+Create this dialogue as if it were part of a real podcast episode, capturing every detail vividly. Start with an exciting introduction that hooks listeners immediately and maintains an appealing tone throughout.
+
+Please rewrite this transcript to highlight each speaker's unique voice and personality.
+
+START YOUR RESPONSE DIRECTLY WITH SPEAKER 1:
+
+STRICTLY RETURN YOUR RESPONSE AS A LIST OF TUPLES ONLY!
+
+THE RESPONSE SHOULD BEGIN AND END WITH THE LIST.
+Example of response:
+[
+    ("Speaker 1", "Welcome to our podcast! Today we explore the latest advancements in AI technology."),
+    ("Speaker 2", "That sounds fascinating! Can you tell me more about what’s new?"),
+    ("Speaker 1", "Absolutely! The latest model from Meta AI has some groundbreaking features..."),
+    ("Speaker 2", "I can't wait to hear all about it!")
+]
+"""

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+PyPDF2
+tqdm
+python-dotenv
+edge-tts
+openai==0.28.0