import gradio as gr from openai import OpenAI import re import json import time from pydub import AudioSegment from io import BytesIO import tempfile import os def create_audio_for_segment(client, speaker, content): """Generate speech audio for a specific segment in memory""" # Map speakers to different voices voice_mapping = { "Author": "echo", # Professional male voice for the author "Student": "alloy", # Younger voice for the student } # Set speaking style based on speaker role instructions_mapping = { "Author": "Speak as an expert researcher explaining technical concepts clearly and confidently.", "Student": "Speak with curiosity and enthusiasm, as someone eager to learn.", } # Get the appropriate voice and instructions voice = voice_mapping.get(speaker, "nova") instructions = instructions_mapping.get(speaker, "Speak naturally.") print(f"Generating audio for {speaker}...") # Create audio in memory with client.audio.speech.with_streaming_response.create( model="gpt-4o-mini-tts", voice=voice, input=content, instructions=instructions, ) as response: # Read the audio data into memory audio_data = BytesIO() for chunk in response.iter_bytes(): audio_data.write(chunk) audio_data.seek(0) # Small delay to avoid rate limiting time.sleep(0.5) return audio_data def combine_audio_segments(audio_segments, opening_sound_path="codecopen.wav", closing_sound_path="codecover.wav"): """Combine multiple audio segments into a single file in memory.""" combined = AudioSegment.empty() # Load opening and closing sounds if provided if opening_sound_path and os.path.exists(opening_sound_path): opening_sound = AudioSegment.from_file(opening_sound_path) else: opening_sound = AudioSegment.silent(duration=1000) # 1 second silence as fallback if closing_sound_path and os.path.exists(closing_sound_path): closing_sound = AudioSegment.from_file(closing_sound_path) else: closing_sound = AudioSegment.silent(duration=1000) # 1 second silence as fallback # Add a short pause between segments pause = AudioSegment.silent(duration=500) # 500ms pause # Start with opening sound combined += opening_sound + pause # Add each segment with pause for audio_data in audio_segments: audio_data.seek(0) # Reset position segment = AudioSegment.from_file(audio_data, format="mp3") combined += segment + pause # End with closing sound combined += closing_sound # Export to bytes output_buffer = BytesIO() combined.export(output_buffer, format="mp3") output_buffer.seek(0) print("Combined audio with opening/closing created in memory") return output_buffer.getvalue() def generate_podcast_from_transcript(client, transcript_data, opening_sound_path="codecopen.wav", closing_sound_path="codecover.wav"): """Generate a podcast from transcript data in memory""" segments = transcript_data['segments'] audio_segments = [] for i, segment in enumerate(segments): speaker = segment['speaker'] content = segment['content'] # Skip very short segments or empty content if len(content.strip()) < 5: continue # Remove any leading "Speaker:" prefix, just in case it's included in content content = re.sub(r'^\s*(Author|Student)\s*:\s*', '', content, flags=re.IGNORECASE) # Remove any text in parentheses (including nested ones up to one level deep) content = re.sub(r'\([^()]*\)', '', content) # Remove any text in square brackets content = re.sub(r'\[[^\[\]]*\]', '', content) # Optionally, strip extra spaces after removing parentheses content = re.sub(r'\s+', ' ', content).strip() audio_data = create_audio_for_segment(client, speaker, content) audio_segments.append(audio_data) # Combine all audio segments audio_bytes = combine_audio_segments(audio_segments, opening_sound_path, closing_sound_path) return audio_bytes def generate_podcast(file, client, opening_sound_path="codecopen.wav", closing_sound_path="codecover.wav"): """ Generate a podcast from a file in memory. Args: file: Gradio file object with .name attribute pointing to the file path client: OpenAI client instance opening_sound_path: Optional path to opening sound file closing_sound_path: Optional path to closing sound file Returns: tuple: (transcript, audio_bytes) - transcript: JSON string of the conversation transcript - audio_bytes: MP3 audio data as bytes """ # Read file content from the Gradio file object with open(file.name, "rb") as f: file_content = f.read() # Create temporary file for OpenAI API (it requires a file path) with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file: temp_file.write(file_content) temp_file_path = temp_file.name try: # Upload file to OpenAI with open(temp_file_path, "rb") as f: file_obj = client.files.create(file=f, purpose="user_data") print("Generating conversation transcript...") # Generate the conversation response = client.responses.create( model="gpt-4o", input=[ { "role": "user", "content": [ { "type": "input_file", "file_id": file_obj.id, }, { "type": "input_text", "text": "You are a podcast curator creating podcasts for scholars by generating scripts between a paper author and a hypothetical student. You will simulate the entire discussion.\n\nGiven a resource for a paper, generate a discussion between the author of the paper Bob and a student who wants to understand it Alice. The discussion flows naturally and should be almost informal, with the author providing intuitive explanations, analogies, and simple takeaways. During the discussion segments, the student should reason with the author, creating \"aha!\" moments instead of just a Q&A session.\n\nThe roles should be clearly indicated in the script to facilitate parsing of the output. At the end, the student summarizes the entire paper, including its pros and cons.\n\n# Roles\n\n- **Author**: Provides explanations, analogies, and simple takeaways.\n- **Student**: Asks questions, reflects, and provides a summary of the paper.\n\n# Output Format\n\nThe output should clearly delineate each segment of the conversation by marking who is speaking. \n\nExample segment: \n- Author: [Author's explanation or dialogue]\n- Student: [Student's question, reasoning, or concluding summary]\n\n# Notes\n\n- Ensure the interaction is dynamic, with contributions from both the author and the student.\n- Focus on creating an educational yet engaging dialogue.\n- End with a clear, concise summary by the student, highlighting the paper's main points, pros, and cons" } ] } ], text={ "format": { "type": "json_schema", "name": "conversation_schema", "schema": { "type": "object", "required": ["segments"], "properties": { "segments": { "type": "array", "items": { "type": "object", "required": ["speaker", "content"], "properties": { "content": { "type": "string", "description": "The dialogue or content spoken by the speaker." }, "speaker": { "type": "string", "description": "The name of the speaker in the segment." } }, "additionalProperties": False }, "description": "A collection of dialogue segments in the conversation." } }, "additionalProperties": False }, "strict": True } }, reasoning={}, tools=[ { "type": "web_search_preview", "user_location": {"type": "approximate"}, "search_context_size": "medium" } ], tool_choice={"type": "web_search_preview"}, temperature=1.05, max_output_tokens=4096, top_p=1, store=False ) # Extract transcript transcript_json = response.model_dump()['output'][1]['content'][0]['text'] transcript_data = json.loads(transcript_json) print("Generating audio...") # Generate podcast audio audio_bytes = generate_podcast_from_transcript( client, transcript_data, opening_sound_path, closing_sound_path ) print("Podcast generation completed successfully!") return transcript_json, audio_bytes finally: # Clean up temporary file os.unlink(temp_file_path) def gradio_interface(api_key, file): """Gradio interface function with proper error handling""" # Check if API key is provided if not api_key or not api_key.strip(): gr.Warning("⚠️ OpenAI API Key is required!") return "", None # Check if file is uploaded if not file: gr.Warning("⚠️ Please upload a PDF file!") return "", None try: # Initialize OpenAI client client = OpenAI(api_key=api_key.strip()) # Test API key validity with a simple request try: client.models.list() except Exception as auth_error: if "authentication" in str(auth_error).lower() or "api key" in str(auth_error).lower(): gr.Error("❌ Invalid OpenAI API Key. Please check your key and try again.") else: gr.Error(f"❌ OpenAI API Error: {str(auth_error)}") return "", None # Generate podcast transcript, audio_bytes = generate_podcast(file, client) if audio_bytes: # Create a temporary file for Gradio to serve the audio with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio: temp_audio.write(audio_bytes) temp_audio_path = temp_audio.name gr.Info("✅ Podcast generated successfully!") return transcript, temp_audio_path else: gr.Error("❌ Failed to generate audio. Please try again.") return transcript, None except Exception as e: error_msg = str(e) if "rate limit" in error_msg.lower(): gr.Error("❌ OpenAI API rate limit exceeded. Please wait a moment and try again.") elif "quota" in error_msg.lower(): gr.Error("❌ OpenAI API quota exceeded. Please check your account billing.") elif "authentication" in error_msg.lower() or "api key" in error_msg.lower(): gr.Error("❌ Invalid OpenAI API Key. Please check your key and try again.") else: gr.Error(f"❌ An error occurred: {error_msg}") return "", None # Gradio Interface with gr.Blocks(title="podXiv - Academic Paper to Podcast") as demo: with gr.Row(): with gr.Column(scale=1): gr.Markdown("# 🎙️ podXiv") gr.Markdown( """ *⚠️ We need your OpenAI API Key!* Welcome to **podXiv**. We convert a PDF paper into an audible podcast! --- **1. Upload & Analyze** - Upload your academic paper (could be any PDF) - AI analyzes the content and structure **2. Generate Dialogue** - Creates natural dialogue between author and student - Focuses on key insights and explanations **3. Create Audio** - Combines the dialogue into a final podcast **Note:** This process may take a few minutes (+/- 80 seconds) as we generate high-quality audio for each segment. The overall podcast has a length between 2.30 and 5.00 minutes. Also, the webapp might not work on mobile. """ ) with gr.Column(scale=2): with gr.Group(): api_key_input = gr.Textbox( label="🤖 Your OpenAI API Key", type="password", placeholder="sk-...", info="Your API key is only used for this session and is not stored." ) file_input = gr.File( label="📄 Upload a paper", file_types=[".pdf"] ) submit_btn = gr.Button("🎬 Generate Podcast", variant="primary", size="lg") # Output components with gr.Accordion("📝 View Transcript", open=False): transcript_output = gr.Textbox( label="Transcript JSON", lines=10, interactive=False, info="Raw JSON transcript of the generated conversation" ) audio_download = gr.File( label="🎵 Download Podcast Audio" ) # Connect the button to the function submit_btn.click( fn=gradio_interface, inputs=[api_key_input, file_input], outputs=[transcript_output, audio_download], show_progress=True ) # Launch the app if __name__ == "__main__": demo.launch( share=True, # Creates a public link server_name="0.0.0.0", # Allows external connections server_port=7860 # Default Gradio port )