Merge branch 'main' of https://huggingface.co/spaces/phxdev/podcaster

Dockerfile

@@ -57,6 +57,6 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy application code
 COPY . .
 
-
+EXPOSE 7863
 # Start the realtime.py script
 CMD ["python", "interface.py"]

README.md

@@ -7,85 +7,14 @@ sdk: gradio
 sdk_version: "5.12.0"
 app_file: app.py
 pinned: false
-python_verson: 3.11
+short_description: A Podcast Generator powered by FastAPI and Gradio
+python_version: "3.12"
 ---
 
-# Gradio Podcast Generator
+# URL to Podcast Generator
 
-This project is a Gradio application that generates a podcast episode based on content scraped from a provided URL. It utilizes various components to scrape the content, generate a podcast script, and convert the script into audio format.
+A FastAPI application with Gradio interface for generating podcasts from web content.
 
-## Project Structure
+## Running the Application
 
-```
-gradio-podcast-generator
-├── src
-│   ├── app.py               # Entry point of the Gradio application
-│   ├── scraper.py           # Contains the scraping logic
-│   ├── podcast_generator.py  # Generates the podcast episode
-│   └── tts.py               # Converts text to speech
-├── requirements.txt         # Lists project dependencies
-└── README.md                # Project documentation
-```
-
-## Setup Instructions
-
-1. Clone the repository:
-   ```
-   git clone https://github.com/yourusername/gradio-podcast-generator.git
-   cd gradio-podcast-generator
-   ```
-
-2. Install the required dependencies:
-   ```
-   pip install -r requirements.txt
-   ```
-
-## Flask Configuration
-
-The application uses Flask with Gradio integration. Here's how to set it up and run it:
-
-1. Install the requirements:
-```bash
-pip install flask gradio
-```
-
-2. Configure the environment:
-```bash
-export FLASK_APP=app.py
-export FLASK_ENV=development  # For development mode
-```
-
-3. Run the application:
-```bash
-python app.py
-```
-
-The server will start on `http://0.0.0.0:7860` with the following configuration:
-- Host: 0.0.0.0 (accessible from any IP)
-- Port: 7860
-- Debug mode: Enabled
-- Gradio interface: Mounted at root path '/'
-
-## Usage
-
-To run the Gradio application, execute the following command in your terminal:
-
-```
-python src/app.py
-```
-
-Once the application is running, you can input a URL into the Gradio interface. The application will scrape the content from the URL, generate a podcast episode, and provide an audio output.
-
-## Functionality
-
-- **Scraping**: The application uses the `scraper.py` module to extract relevant text from the provided URL.
-- **Podcast Generation**: The `podcast_generator.py` module utilizes the `eva-unit-01/eva-llama-3.33-70b` model to create a podcast script that is no longer than 3 minutes.
-- **Text-to-Speech**: The `tts.py` module converts the generated podcast script into audio using the ElevenLabs TTS API.
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a pull request or open an issue for any enhancements or bug fixes.
-
-## License
-
-This project is licensed under the MIT License. See the LICENSE file for more details.
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api_clients.py

@@ -2,8 +2,10 @@ from functools import lru_cache
 from typing import List, Tuple, Optional
 import aiohttp
 import elevenlabs
+import time
 from contextlib import asynccontextmanager
 from logger import setup_logger, log_execution_time, log_async_execution_time
+from models import OpenRouterRequest, OpenRouterResponse, Message, OpenRouterModel
 
 logger = setup_logger("api_clients")
 
@@ -12,18 +14,31 @@ class OpenRouterClient:
     
     def __init__(self, api_key: str):
         logger.info("Initializing OpenRouter client")
-        if not api_key or len(api_key) < 32:
-            logger.error("Invalid API key format")
-            raise ValueError("Invalid OpenRouter API key")
-            
         self.api_key = api_key
         self.base_url = "https://openrouter.ai/api/v1"
         self.headers = {
             "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
+            "Content-Type": "application/json"
         }
         logger.debug("OpenRouter client initialized successfully")
     
+    @property
+    def api_key(self):
+        return self._api_key
+
+    @api_key.setter
+    def api_key(self, value: str):
+        if not value or len(value) < 32:
+            logger.error("Invalid API key format")
+            raise ValueError("Invalid OpenRouter API key")
+        self._api_key = value
+        # Update headers when API key changes
+        self.headers = {
+            "Authorization": f"Bearer {value}",
+            "Content-Type": "application/json",
+        }
+        logger.info("OpenRouter API key updated successfully")
+    
     @asynccontextmanager
     async def get_session(self):
         logger.debug("Creating new aiohttp session")
@@ -33,7 +48,7 @@ class OpenRouterClient:
     @lru_cache(maxsize=1)
     async def get_models(self) -> List[Tuple[str, str]]:
         """
-        Fetch available models from OpenRouter API
+        Fetch available models from OpenRouter API using pydantic models
         
         Returns:
             List of tuples containing (model_id, model_description)
@@ -44,16 +59,11 @@ class OpenRouterClient:
         logger.info("Fetching available models from OpenRouter")
         async with self.get_session() as session:
             async with session.get(f"{self.base_url}/models") as response:
-                if response.status != 200:
-                    error_msg = await response.text()
-                    logger.error(f"Failed to fetch models: {error_msg}")
-                    raise ValueError(f"Failed to fetch models: {error_msg}")
-                
-                models = await response.json()
+                response.raise_for_status()
+                data = await response.json()
+                models = [OpenRouterModel(**model) for model in data["data"]]
                 logger.info(f"Successfully fetched {len(models)} models")
-                logger.debug(f"Available models: {[model['name'] for model in models]}")
-                return [(model['id'], f"{model['name']} ({model['context_length']} tokens)") 
-                        for model in models]
+                return [(model.id, model.name) for model in models]
 
     @log_async_execution_time(logger)
     async def generate_script(self, content: str, prompt: str, model_id: str) -> str:
@@ -75,77 +85,53 @@ class OpenRouterClient:
             raise ValueError("Please provide a more detailed prompt")
         
         try:
+            request = OpenRouterRequest(
+                model=model_id,
+                messages=[
+                    Message(role="system", content="You are a podcast script writer."),
+                    Message(role="user", content=f"Create a podcast script from this content: {content}")
+                ]
+            )
+            
             async with self.get_session() as session:
-                logger.debug("Preparing script generation request")
-                response = await self._make_script_request(session, content, prompt, model_id)
-                
-                script = response['choices'][0]['message']['content']
-                logger.info(f"Script generated successfully: {len(script)} chars")
-                logger.debug(f"Script preview: {script[:200]}...")
-                
-                return script
+                async with session.post(
+                    f"{self.base_url}/chat/completions",
+                    json=request.dict()
+                ) as response:
+                    response.raise_for_status()
+                    data = await response.json()
+                    router_response = OpenRouterResponse(**data)
+                    return router_response.choices[0].message.content
         except Exception as e:
             logger.error(f"Script generation failed", exc_info=True)
             raise
 
-    async def _make_script_request(self, session, content, prompt, model_id):
-        async with session.post(
-            f"{self.base_url}/chat/completions",
-            json={
-                "model": model_id,
-                "messages": [
-                    {
-                        "role": "system",
-                        "content": "You are an expert podcast script writer. Create engaging, conversational content."
-                    },
-                    {
-                        "role": "user",
-                        "content": f"""Based on this content: {content}
-                        Create a 3-minute podcast script focusing on: {prompt}
-                        Format as a natural conversation with clear speaker parts.
-                        Include [HOST] and [GUEST] markers for different voices."""
-                    }
-                ]
-            }
-        ) as response:
-            logger.debug("Sending script generation request")
-            
-            if response.status != 200:
-                error_msg = await response.text()
-                logger.error(f"Script generation failed: {error_msg}")
-                raise ValueError(f"Script generation failed: {error_msg}")
-            
-            return await response.json()
-
 class ElevenLabsClient:
-    """Handles ElevenLabs API interactions with detailed performance tracking"""
-    
     def __init__(self, api_key: str):
-        logger.info("Initializing ElevenLabs client")
         self.api_key = api_key
         elevenlabs.set_api_key(api_key)
-    
-    @lru_cache(maxsize=1)
+
     def get_voices(self) -> List[Tuple[str, str]]:
         """
-        Fetch available voices from ElevenLabs
+        Synchronously get available voices from ElevenLabs
         
         Returns:
-            List of tuples containing (voice_id, voice_name)
-        """
-        logger.info("Fetching available voices from ElevenLabs")
-        voices = elevenlabs.voices()
-        logger.info(f"Successfully fetched {len(voices)} voices")
-        logger.debug(f"Available voices: {[voice.name for voice in voices]}")
-        return [(voice.voice_id, voice.name) for voice in voices]
-    
-    @log_execution_time(logger)
-    def generate_audio(self, text: str, voice_id: str) -> bytes:
-        """
-        Generate audio with comprehensive error handling and quality checks
-        
-        Logs detailed metrics about the input text and resulting audio.
+            List of tuples containing (voice_id, display_name)
+            where display_name shows the name and description but not the ID
         """
+        try:
+            voices = elevenlabs.voices()
+            return [(
+                voice.voice_id,  # Value (hidden from user)
+                f"{voice.name} ({voice.labels.get('accent', 'No accent')})" + 
+                (f" - {voice.description[:50]}..." if voice.description else "")
+            ) for voice in voices]
+        except Exception as e:
+            logger.error("Failed to fetch voices from ElevenLabs", exc_info=True)
+            raise
+
+    async def generate_audio(self, text: str, voice_id: str):
+        """Asynchronously generate audio"""
         logger.info(f"Starting audio generation with voice: {voice_id}")
         logger.debug(f"Input text length: {len(text)} chars")
         
@@ -154,7 +140,7 @@ class ElevenLabsClient:
         
         try:
             start_time = time.time()
-            audio = elevenlabs.generate(
+            audio = await elevenlabs.generate(  # Assuming elevenlabs supports async
                 text=text,
                 voice=voice_id,
                 model="eleven_monolingual_v1"

app.py

@@ -1,38 +1,120 @@
-from flask import Flask, render_template
+import asyncio
+import os
 import gradio as gr
+from api_clients import OpenRouterClient, ElevenLabsClient
+from logger import setup_logger
+from config import Config
 from scraper import scrape_url
-from podcast_generator import PodcastGenerator
-from tts import text_to_speech
-
-app = Flask(__name__)
-
-def generate_podcast(url):
-    content = scrape_url(url)
-    podcast_generator = PodcastGenerator()
-    podcast_text = podcast_generator.generate_podcast(content)
-    audio_file = text_to_speech(podcast_text)
-    return audio_file
-
-# Create Gradio interface
-demo = gr.Interface(
-    fn=generate_podcast,
-    inputs=gr.Textbox(
-        label="Website URL",
-        placeholder="Enter the URL of the website you want to convert to a podcast"
-    ),
-    outputs=gr.Audio(label="Generated Podcast"),
-    title="URL to Podcast Generator",
-    description="Enter a URL to generate a podcast episode based on its content.",
-    theme="huggingface",
-    allow_flagging="never",
-)
-
-# Mount Gradio interface to Flask
-app = gr.mount_gradio_app(app, demo, path="/")
+
+logger = setup_logger("app")
+
+# Default choices for dropdowns
+default_voices = [("", "Enter API key to load voices")]
+default_models = [("", "Enter API key to load models")]
+
+class PodcasterUI:
+    def __init__(self, config: Config):
+        self.config = config
+        self.router_client = OpenRouterClient(os.getenv('OPENROUTER_API_KEY', ''))
+        self.elevenlabs_client = ElevenLabsClient(os.getenv('ELEVENLABS_API_KEY', ''))
+        # Store models and voices as instance variables
+        self.models = default_models
+        self.voices = default_voices
+
+    async def initialize(self):
+        """Initialize API clients and fetch models/voices"""
+        try:
+            self.models = await self.router_client.get_models()
+            # Since get_voices() might not be async, remove await
+            self.voices = self.elevenlabs_client.get_voices()
+            logger.info(f"Initialized with {len(self.voices)} voices and {len(self.models)} models")
+        except Exception as e:
+            logger.error("Failed to initialize API clients", exc_info=True)
+            raise
+
+    async def on_submit(self, content: str, model_id: str, voice_id: str, prompt: str = "") -> tuple:
+        """Handle form submission with async API calls"""
+        try:
+            # First scrape the webpage content
+            webpage_content = scrape_url(content)
+            if not webpage_content:
+                return "Failed to extract content from URL", None
+
+            # Generate script using the scraped content
+            script = await self.router_client.generate_script(webpage_content, prompt, model_id)
+            
+            # Generate audio from the script
+            audio = await self.elevenlabs_client.generate_audio(script, voice_id)
+            return script, audio
+        except Exception as e:
+            logger.error("Failed to generate podcast", exc_info=True)
+            return str(e), None
+
+    def create_ui(self) -> gr.Interface:
+        with gr.Blocks(title='URL to Podcast Generator', theme='huggingface') as interface:
+            gr.Markdown('# URL to Podcast Generator')
+            gr.Markdown('Enter a URL to generate a podcast episode based on its content.')
+
+            with gr.Row():
+                with gr.Column(scale=2):
+                    url_input = gr.Textbox(
+                        label="Website URL",
+                        placeholder="Enter the URL of the website you want to convert to a podcast"
+                    )
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            openrouter_model = gr.Dropdown(
+                                label='AI Model',
+                                choices=[(name, id) for id, name in self.models],  # Swap order for display
+                                value=self.models[0][1] if len(self.models) > 1 else None,
+                                type="index"  # Use index to get the second element (id) from tuple
+                            )
+                            
+                        with gr.Column():
+                            voice_model = gr.Dropdown(
+                                label='Voice',
+                                choices=[(name, id) for id, name in self.voices],  # Swap order for display
+                                value=self.voices[0][1] if len(self.voices) > 1 else None,
+                                type="index"  # Use index to get the second element (id) from tuple
+                            )
+                    
+                    prompt_input = gr.Textbox(
+                        label="Custom Prompt",
+                        placeholder="Enter a custom prompt to guide the podcast generation (optional)",
+                        lines=3
+                    )
+                    
+                    submit_btn = gr.Button('Generate Podcast', variant='primary')
+
+                with gr.Column(scale=1):
+                    script_output = gr.Textbox(label="Generated Script", interactive=False)
+                    audio_output = gr.Audio(label="Generated Podcast")
+                    status = gr.Textbox(label='Status', interactive=False)
+
+            submit_btn.click(
+                fn=self.on_submit,
+                inputs=[url_input, openrouter_model, voice_model, prompt_input],
+                outputs=[script_output, audio_output]
+            )
+
+        return interface
+
+def main():
+    config = Config()
+    app = PodcasterUI(config)
+    
+    # Initialize before creating UI
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(app.initialize())
+    
+    # Create UI with populated data
+    interface = app.create_ui()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )
 
 if __name__ == "__main__":
-    app.run(
-        host="0.0.0.0",
-        port=7860,
-        debug=True
-    )
+    main()

config.py

@@ -0,0 +1,8 @@
+import os
+from dotenv import load_dotenv
+
+class Config:
+    def __init__(self):
+        load_dotenv()
+        self.openrouter_api_key = os.getenv('OPENROUTER_API_KEY', '')
+        self.elevenlabs_api_key = os.getenv('ELEVENLABS_API_KEY', '')

models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class OpenRouterRequest(BaseModel):
+    model: str
+    messages: List[Message]
+
+class Choice(BaseModel):
+    message: Message
+    index: int = 0
+    finish_reason: Optional[str] = None
+
+class OpenRouterResponse(BaseModel):
+    id: str
+    choices: List[Choice]
+    model: str
+
+class OpenRouterModel(BaseModel):
+    id: str
+    name: str
+    description: Optional[str] = None

requirements.txt

@@ -1,10 +1,13 @@
 gradio==3.0.0
 browser-use
 elevenlabs==0.2.26
-flask==3.0.0
 pydub==0.25.1           # audio processing library
 python-dotenv==1.0.0    # for environment variables
 requests==2.31.0        # for API calls
 numpy>1.24.3           # common dependency
 openrouter
-trafilatura>=1.6.1
+uvicorn
+fastapi
+langchain_anthropic
+langchain_openai
+langchain_google_genai