Properly awaiting now

api_clients.py

@@ -2,6 +2,7 @@ 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
@@ -47,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)
@@ -56,14 +57,13 @@ class OpenRouterClient:
             ValueError: If API request fails
         """
         logger.info("Fetching available models from OpenRouter")
-        response = requests.get(
-            f"{self.base_url}/models",
-            headers=self.headers
-        )
-        response.raise_for_status()
-        models = [OpenRouterModel(**model) for model in response.json()["data"]]
-        logger.info(f"Successfully fetched {len(models)} models")
-        return [(model.id, model.name) for model in models]
+        async with self.get_session() as session:
+            async with session.get(f"{self.base_url}/models") as response:
+                response.raise_for_status()
+                data = await response.json()
+                models = [OpenRouterModel(**model) for model in data["data"]]
+                logger.info(f"Successfully fetched {len(models)} 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:
@@ -93,15 +93,15 @@ class OpenRouterClient:
                 ]
             )
             
-            response = requests.post(
-                f"{self.base_url}/chat/completions",
-                headers=self.headers,
-                data=request.json()
-            )
-            response.raise_for_status()
-            
-            router_response = OpenRouterResponse(**response.json())
-            return router_response.choices[0].message.content
+            async with self.get_session() as session:
+                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
@@ -130,7 +130,7 @@ class ElevenLabsClient:
         self.get_voices.cache_clear()
     
     @lru_cache(maxsize=1)
-    def get_voices(self) -> List[Tuple[str, str]]:
+    async def get_voices(self) -> List[Tuple[str, str]]:
         """
         Fetch available voices from ElevenLabs
         
@@ -139,25 +139,29 @@ class ElevenLabsClient:
             where display_name includes voice description if available
         """
         logger.info("Fetching available voices from ElevenLabs")
-        voices = elevenlabs.voices()
-        logger.info(f"Successfully fetched {len(voices)} voices")
-        
-        voice_list = []
-        for voice in voices:
-            # Create descriptive name including accent and age if available
-            description = f"{voice.name}"
-            if hasattr(voice, 'labels') and voice.labels:
-                if 'accent' in voice.labels:
-                    description += f" ({voice.labels['accent']})"
-                if 'age' in voice.labels:
-                    description += f", {voice.labels['age']}"
-            voice_list.append((voice.voice_id, description))
+        try:
+            voices = await elevenlabs.voices()  # Assuming elevenlabs supports async
+            logger.info(f"Successfully fetched {len(voices)} voices")
             
-        logger.debug(f"Available voices: {[name for _, name in voice_list]}")
-        return voice_list
-    
-    @log_execution_time(logger)
-    def generate_audio(self, text: str, voice_id: str) -> bytes:
+            voice_list = []
+            for voice in voices:
+                # Create descriptive name including accent and age if available
+                description = f"{voice.name}"
+                if hasattr(voice, 'labels') and voice.labels:
+                    if 'accent' in voice.labels:
+                        description += f" ({voice.labels['accent']})"
+                    if 'age' in voice.labels:
+                        description += f", {voice.labels['age']}"
+                voice_list.append((voice.voice_id, description))
+                
+            logger.debug(f"Available voices: {[name for _, name in voice_list]}")
+            return voice_list
+        except Exception as e:
+            logger.error("Failed to fetch voices", exc_info=True)
+            raise
+
+    @log_async_execution_time(logger)
+    async def generate_audio(self, text: str, voice_id: str) -> bytes:
         """
         Generate audio with comprehensive error handling and quality checks
         
@@ -171,7 +175,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

@@ -7,6 +7,10 @@ from scraper import scrape_url
 from podcast_generator import PodcastGenerator
 from tts import text_to_speech
 from api_clients import OpenRouterClient, ElevenLabsClient
+from logger import setup_logger
+from config import Config
+
+logger = setup_logger("app")
 
 load_dotenv()
 
@@ -14,114 +18,128 @@ load_dotenv()
 default_voices = [("", "Enter API key to load voices")]
 default_models = [("", "Enter API key to load models")]
 
-async def generate_podcast(
-    url: str,
-    openrouter_key: str,
-    model_id: str,
-    elevenlabs_key: str,
-    voice_id: str
-) -> Optional[str]:
-    try:
-        content = scrape_url(url)
-        
-        # Initialize API clients
-        openrouter = OpenRouterClient(openrouter_key)
-        elevenlabs = ElevenLabsClient(elevenlabs_key)
-        
-        # Generate script using OpenRouter
-        script = await openrouter.generate_script(content, model_id)
-        
-        # Convert to audio using ElevenLabs
-        audio_file = elevenlabs.generate_audio(script, voice_id)
-        return audio_file
-    except Exception as e:
-        return f"Error: {str(e)}"
+class PodcasterUI:
+    def __init__(self, config: Config):
+        self.config = config
+        self.router_client = OpenRouterClient(config.openrouter_api_key)
+        self.elevenlabs_client = ElevenLabsClient(config.elevenlabs_api_key)
+        # Store models and voices as instance variables
+        self.models = []
+        self.voices = []
+
+    async def initialize(self):
+        """Initialize API clients and fetch models/voices"""
+        try:
+            self.models = await self.router_client.get_models()
+            self.voices = await self.elevenlabs_client.get_voices()
+        except Exception as e:
+            logger.error("Failed to initialize API clients", exc_info=True)
+            raise
 
-def create_ui():
-    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.')
+    async def on_submit(self, content: str, model_id: str, voice_id: str, prompt: str = "") -> tuple:
+        """Handle form submission with async API calls"""
+        try:
+            script = await self.router_client.generate_script(content, prompt, model_id)
+            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
 
-        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_key = gr.Textbox(
-                            label='OpenRouter API Key',
-                            type='password',
-                            placeholder='Enter key...'
-                        )
-                        openrouter_model = gr.Dropdown(
-                            label='AI Model',
-                            choices=default_models,
-                            value=None,
-                            allow_custom_value=True
-                        )
-                        
-                    with gr.Column():
-                        elevenlabs_key = gr.Textbox(
-                            label='ElevenLabs API Key',
-                            type='password',
-                            placeholder='Enter key...'
-                        )
-                        voice_model = gr.Dropdown(
-                            label='Voice',
-                            choices=default_voices,
-                            value=None,
-                            allow_custom_value=True
-                        )
-                
-                submit_btn = gr.Button('Generate Podcast', variant='primary')
+    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.Column(scale=1):
-                audio_output = gr.Audio(label="Generated Podcast")
-                status = gr.Textbox(label='Status', interactive=False)
+            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_key = gr.Textbox(
+                                label='OpenRouter API Key',
+                                type='password',
+                                placeholder='Enter key...'
+                            )
+                            openrouter_model = gr.Dropdown(
+                                label='AI Model',
+                                choices=default_models,
+                                value=None,
+                                allow_custom_value=True
+                            )
+                            
+                        with gr.Column():
+                            elevenlabs_key = gr.Textbox(
+                                label='ElevenLabs API Key',
+                                type='password',
+                                placeholder='Enter key...'
+                            )
+                            voice_model = gr.Dropdown(
+                                label='Voice',
+                                choices=default_voices,
+                                value=None,
+                                allow_custom_value=True
+                            )
+                    
+                    submit_btn = gr.Button('Generate Podcast', variant='primary')
 
-        # Event handlers for API key changes
-        async def update_openrouter_models(key):
-            if not key:
-                return gr.Dropdown(choices=default_models)
-            try:
-                client = OpenRouterClient(key)
-                models = await client.get_models()
-                return gr.Dropdown(choices=models)
-            except Exception as e:
-                return gr.Dropdown(choices=[("error", f"Error: {str(e)}")])
+                with gr.Column(scale=1):
+                    audio_output = gr.Audio(label="Generated Podcast")
+                    status = gr.Textbox(label='Status', interactive=False)
 
-        def update_elevenlabs_voices(key):
-            if not key:
-                return gr.Dropdown(choices=default_voices)
-            try:
-                client = ElevenLabsClient(key)
-                voices = client.get_voices()
-                return gr.Dropdown(
-                    choices={name: id for id, name in voices}
-                )
-            except Exception as e:
-                return gr.Dropdown(choices={"Error": None})
+            # Event handlers for API key changes
+            async def update_openrouter_models(key):
+                if not key:
+                    return gr.Dropdown(choices=default_models)
+                try:
+                    client = OpenRouterClient(key)
+                    models = await client.get_models()
+                    return gr.Dropdown(choices=models)
+                except Exception as e:
+                    return gr.Dropdown(choices=[("error", f"Error: {str(e)}")])
 
-        # Set up event handlers
-        openrouter_key.change(fn=update_openrouter_models, inputs=openrouter_key, outputs=openrouter_model)
-        elevenlabs_key.change(fn=update_elevenlabs_voices, inputs=elevenlabs_key, outputs=voice_model)
-        
-        submit_btn.click(
-            fn=lambda *args: asyncio.run(generate_podcast(*args)),
-            inputs=[url_input, openrouter_key, openrouter_model, elevenlabs_key, voice_model],
-            outputs=[audio_output]
-        )
+            async def update_elevenlabs_voices(key):
+                if not key:
+                    return gr.Dropdown(choices=default_voices)
+                try:
+                    client = ElevenLabsClient(key)
+                    voices = await client.get_voices()
+                    return gr.Dropdown(
+                        choices={name: id for id, name in voices}
+                    )
+                except Exception as e:
+                    return gr.Dropdown(choices={"Error": None})
 
-    return interface
+            # Set up event handlers
+            openrouter_key.change(fn=update_openrouter_models, inputs=openrouter_key, outputs=openrouter_model)
+            elevenlabs_key.change(fn=update_elevenlabs_voices, inputs=elevenlabs_key, outputs=voice_model)
+            
+            submit_btn.click(
+                fn=self.on_submit,
+                inputs=[url_input, openrouter_model, voice_model],
+                outputs=[audio_output]
+            )
 
-if __name__ == '__main__':
+        return interface
 
-    demo = create_ui()
-    demo.launch(
+def main():
+    config = Config()
+    app = PodcasterUI(config)
+    
+    # Create and run initialization coroutine
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(app.initialize())
+    
+    interface = app.create_ui()
+    interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=True
-    )
+    )
+
+if __name__ == "__main__":
+    main()