Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import base64 | |
| import mimetypes | |
| import os | |
| import re | |
| import struct | |
| import tempfile | |
| import asyncio | |
| import logging | |
| from google import genai | |
| from google.genai import types | |
| # Configure logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| # Direct API key - WARNING: This is not recommended for production use | |
| GEMINI_API_KEY = "AIzaSyDy5hjn9NFamWhBjqsVsD2WSoFNr2MrHSw" | |
| def save_binary_file(file_name, data): | |
| """Save binary data to a file.""" | |
| with open(file_name, "wb") as f: | |
| f.write(data) | |
| return file_name | |
| def convert_to_wav(audio_data: bytes, mime_type: str) -> bytes: | |
| """Generates a WAV file header for the given audio data and parameters.""" | |
| parameters = parse_audio_mime_type(mime_type) | |
| bits_per_sample = parameters["bits_per_sample"] | |
| sample_rate = parameters["rate"] | |
| num_channels = 1 | |
| data_size = len(audio_data) | |
| bytes_per_sample = bits_per_sample // 8 | |
| block_align = num_channels * bytes_per_sample | |
| byte_rate = sample_rate * block_align | |
| chunk_size = 36 + data_size | |
| header = struct.pack( | |
| "<4sI4s4sIHHIIHH4sI", | |
| b"RIFF", # ChunkID | |
| chunk_size, # ChunkSize (total file size - 8 bytes) | |
| b"WAVE", # Format | |
| b"fmt ", # Subchunk1ID | |
| 16, # Subchunk1Size (16 for PCM) | |
| 1, # AudioFormat (1 for PCM) | |
| num_channels, # NumChannels | |
| sample_rate, # SampleRate | |
| byte_rate, # ByteRate | |
| block_align, # BlockAlign | |
| bits_per_sample, # BitsPerSample | |
| b"data", # Subchunk2ID | |
| data_size # Subchunk2Size (size of audio data) | |
| ) | |
| return header + audio_data | |
| def parse_audio_mime_type(mime_type: str) -> dict: | |
| """Parses bits per sample and rate from an audio MIME type string.""" | |
| bits_per_sample = 16 | |
| rate = 24000 | |
| parts = mime_type.split(";") | |
| for param in parts: | |
| param = param.strip() | |
| if param.lower().startswith("rate="): | |
| try: | |
| rate_str = param.split("=", 1)[1] | |
| rate = int(rate_str) | |
| except (ValueError, IndexError): | |
| pass | |
| elif param.startswith("audio/L"): | |
| try: | |
| bits_per_sample = int(param.split("L", 1)[1]) | |
| except (ValueError, IndexError): | |
| pass | |
| return {"bits_per_sample": bits_per_sample, "rate": rate} | |
| def fetch_web_content(url, progress=None): | |
| """Fetch and analyze web content using Gemini with tools.""" | |
| try: | |
| if progress: | |
| progress(0.1, desc="Initializing Gemini client...") | |
| logger.info("Initializing Gemini client...") | |
| if not GEMINI_API_KEY: | |
| raise ValueError("GEMINI_API_KEY is not set") | |
| client = genai.Client(api_key=GEMINI_API_KEY) | |
| if progress: | |
| progress(0.2, desc="Fetching web content...") | |
| logger.info(f"Fetching content from URL: {url}") | |
| model = "gemini-2.0-flash-exp" # Updated model name | |
| contents = [ | |
| types.Content( | |
| role="user", | |
| parts=[ | |
| types.Part.from_text(text=f"""Please analyze the content from this URL: {url} | |
| Create a comprehensive summary that would be suitable for a podcast discussion between two hosts. | |
| Focus on the key points, interesting aspects, and discussion-worthy topics. | |
| Format your response as a natural conversation between two podcast hosts discussing the content."""), | |
| ], | |
| ), | |
| ] | |
| tools = [ | |
| types.Tool(url_context=types.UrlContext()), | |
| types.Tool(google_search=types.GoogleSearch()), | |
| ] | |
| generate_content_config = types.GenerateContentConfig( | |
| tools=tools, | |
| response_mime_type="text/plain", | |
| ) | |
| if progress: | |
| progress(0.4, desc="Analyzing content with AI...") | |
| logger.info("Generating content with Gemini...") | |
| content_text = "" | |
| for chunk in client.models.generate_content_stream( | |
| model=model, | |
| contents=contents, | |
| config=generate_content_config, | |
| ): | |
| if chunk.text: | |
| content_text += chunk.text | |
| if progress: | |
| progress(0.6, desc="Content analysis complete!") | |
| logger.info(f"Content generation complete. Length: {len(content_text)} characters") | |
| return content_text | |
| except Exception as e: | |
| logger.error(f"Error in fetch_web_content: {e}") | |
| raise e | |
| def generate_podcast_from_content(content_text, speaker1_name="Anna Chope", speaker2_name="Adam Chan", progress=None): | |
| """Generate audio podcast from text content.""" | |
| try: | |
| if progress: | |
| progress(0.7, desc="Generating podcast audio...") | |
| logger.info("Starting audio generation...") | |
| if not GEMINI_API_KEY: | |
| raise ValueError("GEMINI_API_KEY is not set") | |
| client = genai.Client(api_key=GEMINI_API_KEY) | |
| model = "gemini-2.0-flash-exp" # Updated model name | |
| podcast_prompt = f"""Please read aloud the following content in a natural podcast interview style with two distinct speakers. | |
| Make it sound conversational and engaging: | |
| {content_text} | |
| If the content is not already in dialogue format, please convert it into a natural conversation between two podcast hosts Speaker 1 {speaker1_name} and Speaker 2 {speaker2_name} discussing the topic. They should introduce themselves at the beginning.""" | |
| contents = [ | |
| types.Content( | |
| role="user", | |
| parts=[ | |
| types.Part.from_text(text=podcast_prompt), | |
| ], | |
| ), | |
| ] | |
| generate_content_config = types.GenerateContentConfig( | |
| temperature=1, | |
| response_modalities=[ | |
| "audio", | |
| ], | |
| speech_config=types.SpeechConfig( | |
| multi_speaker_voice_config=types.MultiSpeakerVoiceConfig( | |
| speaker_voice_configs=[ | |
| types.SpeakerVoiceConfig( | |
| speaker="Speaker 1", | |
| voice_config=types.VoiceConfig( | |
| prebuilt_voice_config=types.PrebuiltVoiceConfig( | |
| voice_name="Zephyr" | |
| ) | |
| ), | |
| ), | |
| types.SpeakerVoiceConfig( | |
| speaker="Speaker 2", | |
| voice_config=types.VoiceConfig( | |
| prebuilt_voice_config=types.PrebuiltVoiceConfig( | |
| voice_name="Puck" | |
| ) | |
| ), | |
| ), | |
| ] | |
| ), | |
| ), | |
| ) | |
| if progress: | |
| progress(0.8, desc="Converting to audio...") | |
| logger.info("Generating audio stream...") | |
| # Create temporary file | |
| temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".wav") | |
| temp_file.close() | |
| audio_chunks = [] | |
| for chunk in client.models.generate_content_stream( | |
| model=model, | |
| contents=contents, | |
| config=generate_content_config, | |
| ): | |
| if ( | |
| chunk.candidates is None | |
| or chunk.candidates[0].content is None | |
| or chunk.candidates[0].content.parts is None | |
| ): | |
| continue | |
| if (chunk.candidates[0].content.parts[0].inline_data and | |
| chunk.candidates[0].content.parts[0].inline_data.data): | |
| inline_data = chunk.candidates[0].content.parts[0].inline_data | |
| data_buffer = inline_data.data | |
| # Convert to WAV if needed | |
| if inline_data.mime_type != "audio/wav": | |
| data_buffer = convert_to_wav(inline_data.data, inline_data.mime_type) | |
| audio_chunks.append(data_buffer) | |
| # Combine all audio chunks | |
| if audio_chunks: | |
| # For simplicity, just use the first chunk (you might want to concatenate them) | |
| final_audio = audio_chunks[0] | |
| save_binary_file(temp_file.name, final_audio) | |
| if progress: | |
| progress(1.0, desc="Podcast generated successfully!") | |
| logger.info(f"Audio file saved: {temp_file.name}") | |
| return temp_file.name | |
| else: | |
| raise ValueError("No audio data generated") | |
| except Exception as e: | |
| logger.error(f"Error in generate_podcast_from_content: {e}") | |
| raise e | |
| def generate_web_podcast(url, speaker1_name, speaker2_name, progress=None): | |
| """Main function to fetch web content and generate podcast.""" | |
| try: | |
| if progress: | |
| progress(0.0, desc="Starting podcast generation...") | |
| logger.info(f"Starting podcast generation for URL: {url}") | |
| # Validate inputs | |
| if not url or not url.strip(): | |
| raise ValueError("Please enter a valid URL") | |
| if not url.startswith(('http://', 'https://')): | |
| raise ValueError("Please enter a valid URL starting with http:// or https://") | |
| if not speaker1_name or not speaker1_name.strip(): | |
| speaker1_name = "Anna Chope" | |
| if not speaker2_name or not speaker2_name.strip(): | |
| speaker2_name = "Adam Chan" | |
| # Step 1: Fetch and analyze web content | |
| content_text = fetch_web_content(url.strip(), progress) | |
| if not content_text or len(content_text.strip()) < 50: | |
| raise ValueError("Unable to extract sufficient content from the URL") | |
| # Step 2: Generate podcast from the content | |
| audio_file = generate_podcast_from_content(content_text, speaker1_name.strip(), speaker2_name.strip(), progress) | |
| logger.info("Podcast generation completed successfully") | |
| return audio_file, "✅ Podcast generated successfully!", content_text | |
| except Exception as e: | |
| error_msg = f"❌ Error generating podcast: {str(e)}" | |
| logger.error(f"Error in generate_web_podcast: {e}") | |
| return None, error_msg, "" | |
| # Create Gradio interface | |
| def create_interface(): | |
| """Create and return the Gradio interface.""" | |
| with gr.Blocks( | |
| title="🎙️ Web-to-Podcast Generator", | |
| theme=gr.themes.Soft(), | |
| analytics_enabled=False | |
| ) as demo: | |
| gr.Markdown(""" | |
| # 🎙️ Web-to-Podcast Generator | |
| Transform any website into an engaging podcast conversation between two AI hosts! | |
| Simply paste a URL and let AI create a natural dialogue discussing the content. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| url_input = gr.Textbox( | |
| label="Website URL", | |
| placeholder="https://example.com", | |
| info="Enter the URL of the website you want to convert to a podcast", | |
| lines=1 | |
| ) | |
| with gr.Row(): | |
| speaker1_input = gr.Textbox( | |
| label="Host 1 Name", | |
| value="Anna Chope", | |
| info="Name of the first podcast host", | |
| lines=1 | |
| ) | |
| speaker2_input = gr.Textbox( | |
| label="Host 2 Name", | |
| value="Adam Chan", | |
| info="Name of the second podcast host", | |
| lines=1 | |
| ) | |
| generate_btn = gr.Button("🎙️ Generate Podcast", variant="primary", size="lg") | |
| with gr.Column(scale=1): | |
| gr.Markdown(""" | |
| ### Instructions: | |
| 1. Enter a website URL | |
| 2. Customize host names (optional) | |
| 3. Click "Generate Podcast" | |
| 4. Wait for the AI to analyze content and create audio | |
| 5. Download your podcast! | |
| ### Examples: | |
| - News articles | |
| - Blog posts | |
| - Product pages | |
| - Documentation | |
| - Research papers | |
| """) | |
| with gr.Row(): | |
| status_output = gr.Textbox(label="Status", interactive=False, lines=2) | |
| with gr.Row(): | |
| audio_output = gr.Audio(label="Generated Podcast", type="filepath") | |
| with gr.Accordion("📝 Generated Script Preview", open=False): | |
| script_output = gr.Textbox( | |
| label="Podcast Script", | |
| lines=10, | |
| interactive=False, | |
| info="Preview of the conversation script generated from the website content" | |
| ) | |
| # Event handlers | |
| generate_btn.click( | |
| fn=generate_web_podcast, | |
| inputs=[url_input, speaker1_input, speaker2_input], | |
| outputs=[audio_output, status_output, script_output], | |
| show_progress=True | |
| ) | |
| # Examples | |
| gr.Examples( | |
| examples=[ | |
| ["https://github.com/weaviate/weaviate", "Anna", "Adam"], | |
| ["https://huggingface.co/blog", "Sarah", "Mike"], | |
| ["https://openai.com/blog", "Emma", "John"], | |
| ], | |
| inputs=[url_input, speaker1_input, speaker2_input], | |
| ) | |
| gr.Markdown(""" | |
| --- | |
| **Note:** API key is now directly embedded in the code for convenience. | |
| The generated podcast will feature two AI voices having a natural conversation about the website content. | |
| """) | |
| return demo | |
| if __name__ == "__main__": | |
| try: | |
| logger.info("Starting Web-to-Podcast Generator...") | |
| demo = create_interface() | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=False, | |
| debug=False, | |
| show_error=True | |
| ) | |
| except Exception as e: | |
| logger.error(f"Failed to launch application: {e}") | |
| print(f"Error: {e}") | |
| raise e |