Added code files

.dockerignore

@@ -0,0 +1,53 @@
+# Python virtual environment
+.venv/
+venv/
+ENV/
+
+# Git
+.git
+.gitignore
+
+# Environment files
+.env
+*.env
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+.Python
+*.so
+
+# Development/IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Documentation
+docs/
+*.md
+
+# Logs and databases
+*.log
+*.sqlite
+*.db
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Test cache
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Distribution/packaging
+dist/
+build/
+*.egg-info/

.gitignore

@@ -0,0 +1 @@
+/.env

Dockerfile

@@ -0,0 +1,62 @@
+FROM python:3.11-slim
+
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    wget \
+    gnupg \
+    curl \
+    unzip \
+    xvfb \
+    libgconf-2-4 \
+    libxss1 \
+    libnss3 \
+    libnspr4 \
+    libasound2 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdbus-1-3 \
+    libdrm2 \
+    libgbm1 \
+    libgtk-3-0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxrandr2 \
+    xdg-utils \
+    fonts-liberation \
+    dbus \
+    xauth \
+    xvfb \
+    supervisor \
+    net-tools \
+    procps \
+    git \
+    python3-numpy \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Rust and set PATH
+ENV RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    PATH="/usr/local/cargo/bin:$PATH"
+
+# Install Rust
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
+# Install Playwright and browsers with system dependencies
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+RUN pip install playwright
+RUN playwright install --with-deps chromium
+RUN playwright install-deps
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+
+# Start the realtime.py script
+CMD ["python", "interface.py"]

api_clients.py

@@ -0,0 +1,171 @@
+from functools import lru_cache
+from typing import List, Tuple, Optional
+import aiohttp
+import elevenlabs
+from contextlib import asynccontextmanager
+from .logger import setup_logger, log_execution_time, log_async_execution_time
+
+logger = setup_logger("api_clients")
+
+class OpenRouterClient:
+    """Handles OpenRouter API interactions with comprehensive logging and error tracking"""
+    
+    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",
+        }
+        logger.debug("OpenRouter client initialized successfully")
+    
+    @asynccontextmanager
+    async def get_session(self):
+        logger.debug("Creating new aiohttp session")
+        async with aiohttp.ClientSession(headers=self.headers) as session:
+            yield session
+    
+    @lru_cache(maxsize=1)
+    async def get_models(self) -> List[Tuple[str, str]]:
+        """
+        Fetch available models from OpenRouter API
+        
+        Returns:
+            List of tuples containing (model_id, model_description)
+        
+        Raises:
+            ValueError: If API request fails
+        """
+        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()
+                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]
+
+    @log_async_execution_time(logger)
+    async def generate_script(self, content: str, prompt: str, model_id: str) -> str:
+        """
+        Generate a podcast script with detailed progress tracking and validation
+        
+        Performance metrics and content analysis are logged at each step.
+        """
+        logger.info(f"Starting script generation with model: {model_id}")
+        logger.debug(f"Input metrics - Content: {len(content)} chars, Prompt: {len(prompt)} chars")
+        
+        # Validate inputs
+        if not content or len(content) < 100:
+            logger.error("Content too short for meaningful script generation")
+            raise ValueError("Insufficient content for script generation")
+            
+        if not prompt or len(prompt) < 10:
+            logger.error("Prompt too short or missing")
+            raise ValueError("Please provide a more detailed prompt")
+        
+        try:
+            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
+        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
+        
+        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.
+        """
+        logger.info(f"Starting audio generation with voice: {voice_id}")
+        logger.debug(f"Input text length: {len(text)} chars")
+        
+        if len(text) > 5000:
+            logger.warning(f"Long text detected ({len(text)} chars), may impact performance")
+        
+        try:
+            start_time = time.time()
+            audio = elevenlabs.generate(
+                text=text,
+                voice=voice_id,
+                model="eleven_monolingual_v1"
+            )
+            
+            duration = time.time() - start_time
+            audio_size = len(audio)
+            logger.info(f"Audio generated: {audio_size} bytes in {duration:.2f} seconds")
+            logger.debug(f"Audio generation rate: {len(text)/duration:.2f} chars/second")
+            
+            return audio
+        except Exception as e:
+            logger.error("Audio generation failed", exc_info=True)
+            raise

interface.py

@@ -0,0 +1,256 @@
+import asyncio
+import os
+import time
+from dataclasses import dataclass
+from typing import List, Optional, AsyncGenerator
+import gradio as gr
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from logger import setup_logger, log_execution_time, log_async_execution_time
+
+from browser_use import Agent, Browser
+from browser_use.browser.browser import BrowserContext
+from api_clients import OpenRouterClient, ElevenLabsClient
+
+load_dotenv()
+
+console = Console()
+logger = setup_logger("interface")
+
+@dataclass
+class ActionResult:
+	is_done: bool
+	extracted_content: Optional[str]
+	error: Optional[str]
+	include_in_memory: bool
+
+
+@dataclass
+class AgentHistoryList:
+	all_results: List[ActionResult]
+	all_model_outputs: List[dict]
+
+
+def parse_agent_history(history_str: str) -> None:
+	# Split the content into sections based on ActionResult entries
+	sections = history_str.split('ActionResult(')
+
+	for i, section in enumerate(sections[1:], 1):  # Skip first empty section
+		# Extract relevant information
+		content = ''
+		if 'extracted_content=' in section:
+			content = section.split('extracted_content=')[1].split(',')[0].strip("'")
+
+		if content:
+			header = Text(f'Step {i}', style='bold blue')
+			panel = Panel(content, title=header, border_style='blue')
+			console.print(panel)
+			console.print()
+
+
+async def run_browser_task(
+	task: str,
+	api_key: str,
+	provider: str = 'openai',
+	model: str = 'gpt-4-vision',
+	headless: bool = True,
+) -> str:
+	if not api_key.strip():
+		return 'Please provide an API key'
+
+	if provider == 'openai':
+		os.environ['OPENAI_API_KEY'] = api_key
+		llm = ChatOpenAI(model=model)
+	elif provider == 'anthropic':
+		os.environ['ANTHROPIC_API_KEY'] = api_key
+		llm = ChatAnthropic(model=model)
+	else:  # google
+		os.environ['GOOGLE_API_KEY'] = api_key
+		llm = ChatGoogleGenerativeAI(model=model)
+
+	try:
+		agent = Agent(
+			task=task,
+			llm=llm,
+			browser=Browser(BrowserContext(headless=True))
+		)
+		result = await agent.run()
+		#  TODO: The result cloud be parsed better
+		return result
+	except Exception as e:
+		return f'Error: {str(e)}'
+
+
+@log_async_execution_time(logger)
+async def scrape_content(url: str) -> str:
+    """
+    Scrape and summarize content from the given URL using browser automation
+    
+    This function performs the following steps:
+    1. Validates the input URL
+    2. Initializes the browser agent
+    3. Extracts and summarizes the content
+    
+    Args:
+        url: Target URL to scrape
+        
+    Returns:
+        Summarized content suitable for podcast generation
+        
+    Raises:
+        ValueError: If URL is invalid or content extraction fails
+    """
+    logger.info(f"Starting content scrape for URL: {url}")
+    
+    # Input validation
+    if not url.startswith(('http://', 'https://')):
+        logger.error(f"Invalid URL format: {url}")
+        raise ValueError("URL must start with http:// or https://")
+    
+    try:
+        logger.debug("Initializing LLM and browser agent")
+        llm = ChatOpenAI(model="gpt-4")
+        agent = Agent(
+            task=f"Visit this URL: {url} and extract the main content. Summarize it in a clear and concise way.",
+            llm=llm,
+            browser=Browser(BrowserContext(headless=True))
+        )
+        
+        logger.info("Executing content extraction")
+        result = await agent.run()
+        
+        logger.debug(f"Content extraction successful. Length: {len(result)} chars")
+        logger.debug(f"Content preview: {result[:200]}...")
+        
+        return result
+    except Exception as e:
+        logger.error(f"Content extraction failed for {url}", exc_info=True)
+        raise
+
+@log_async_execution_time(logger)
+async def create_podcast(
+    url: str,
+    prompt: str,
+    elevenlabs_key: str,
+    voice_id: str,
+    openrouter_key: str,
+    model_id: str,
+) -> AsyncGenerator[tuple[Optional[str], str], None]:
+    """
+    Create a podcast through a multi-step process:
+    1. Content extraction from URL
+    2. Script generation using AI
+    3. Voice synthesis
+    
+    Progress updates are yielded at each step for UI feedback.
+    """
+    logger.info(f"Starting podcast creation for URL: {url}")
+    logger.debug(f"Parameters - Voice: {voice_id}, Model: {model_id}")
+    logger.debug(f"Prompt length: {len(prompt)} chars")
+    
+    try:
+        # Initialize clients with validation
+        logger.debug("Initializing API clients")
+        openrouter = OpenRouterClient(openrouter_key)
+        elevenlabs = ElevenLabsClient(elevenlabs_key)
+        
+        # Phase 1: Content scraping
+        logger.info("Phase 1/3: Content scraping")
+        yield None, "Scraping website content..."
+        content = await scrape_content(url)
+        logger.debug(f"Scraped content length: {len(content)} chars")
+        
+        # Phase 2: Script generation
+        logger.info("Phase 2/3: Script generation")
+        yield None, "Generating podcast script..."
+        script = await openrouter.generate_script(content, prompt, model_id)
+        logger.debug(f"Generated script length: {len(script)} chars")
+        
+        # Phase 3: Audio synthesis
+        logger.info("Phase 3/3: Audio generation")
+        yield None, "Converting to audio..."
+        audio = elevenlabs.generate_audio(script, voice_id)
+        logger.debug(f"Generated audio size: {len(audio)} bytes")
+        
+        # Save output
+        audio_path = f"podcast_{int(time.time())}.mp3"
+        logger.debug(f"Saving audio to: {audio_path}")
+        with open(audio_path, "wb") as f:
+            f.write(audio)
+        
+        logger.info("Podcast creation completed successfully")
+        yield audio_path, "Podcast created successfully!"
+        
+    except Exception as e:
+        logger.error("Podcast creation failed", exc_info=True)
+        yield None, f"Error: {str(e)}"
+
+def create_ui():
+    logger.info("Initializing Gradio interface")
+    with gr.Blocks(title='PodcastCreator', theme=gr.themes.Soft()) as interface:
+        with gr.Row():
+            with gr.Column(scale=2):
+                url_input = gr.Textbox(label='Source URL', placeholder='Enter the URL...')
+                prompt = gr.Textbox(label='Podcast Topic', lines=3)
+                
+                with gr.Row():
+                    with gr.Column():
+                        elevenlabs_key = gr.Textbox(
+                            label='ElevenLabs API Key',
+                            type='password',
+                            placeholder='Enter key...'
+                        )
+                        voice = gr.Dropdown(label='Voice', choices=[])
+                    
+                    with gr.Column():
+                        openrouter_key = gr.Textbox(
+                            label='OpenRouter API Key',
+                            type='password',
+                            placeholder='Enter key...'
+                        )
+                        model = gr.Dropdown(label='AI Model', choices=[])
+                
+                submit_btn = gr.Button('Create Podcast', variant='primary')
+
+            with gr.Column(scale=1):
+                audio_output = gr.Audio(label="Generated Podcast")
+                status = gr.Textbox(label='Status', interactive=False)
+
+        # Event handlers
+        def update_voices(key):
+            if not key:
+                return gr.Dropdown(choices=[])
+            try:
+                client = ElevenLabsClient(key)
+                voices = client.get_voices()
+                return gr.Dropdown(choices=voices)
+            except Exception as e:
+                return gr.Dropdown(choices=[("", f"Error: {str(e)}")])
+
+        async def update_models(key):
+            if not key:
+                return gr.Dropdown(choices=[])
+            try:
+                client = OpenRouterClient(key)
+                models = await client.get_models()
+                return gr.Dropdown(choices=models)
+            except Exception as e:
+                return gr.Dropdown(choices=[("", f"Error: {str(e)}")])
+
+        elevenlabs_key.change(fn=update_voices, inputs=elevenlabs_key, outputs=voice)
+        openrouter_key.change(fn=update_models, inputs=openrouter_key, outputs=model)
+        
+        submit_btn.click(
+            fn=create_podcast,
+            inputs=[url_input, prompt, elevenlabs_key, voice, openrouter_key, model],
+            outputs=[audio_output, status]
+        )
+
+    return interface
+
+if __name__ == '__main__':
+    demo = create_ui()
+    demo.launch()

logger.py

@@ -0,0 +1,72 @@
+import logging
+import sys
+import time
+from functools import wraps
+from typing import Callable, Any
+from rich.logging import RichHandler
+from rich.console import Console
+
+console = Console()
+
+def setup_logger(name: str, level: str = "INFO") -> logging.Logger:
+    """
+    Configure and return a Rich-formatted logger with enhanced debugging capabilities
+    
+    Args:
+        name: Logger identifier, typically module name
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    
+    Returns:
+        Configured logger instance with rich formatting and error tracing
+    """
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+        datefmt="[%X]",
+        handlers=[
+            RichHandler(rich_tracebacks=True, markup=True),
+            logging.FileHandler(f"{name}.log")  # Also log to file
+        ]
+    )
+    
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    return logger
+
+def log_execution_time(logger: logging.Logger) -> Callable:
+    """Decorator to log function execution time"""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            start_time = time.time()
+            logger.debug(f"Starting {func.__name__} with args: {args}, kwargs: {kwargs}")
+            
+            try:
+                result = func(*args, **kwargs)
+                execution_time = time.time() - start_time
+                logger.debug(f"Completed {func.__name__} in {execution_time:.2f} seconds")
+                return result
+            except Exception as e:
+                logger.error(f"Error in {func.__name__}: {str(e)}", exc_info=True)
+                raise
+        return wrapper
+    return decorator
+
+def log_async_execution_time(logger: logging.Logger) -> Callable:
+    """Decorator to log async function execution time"""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            start_time = time.time()
+            logger.debug(f"Starting async {func.__name__} with args: {args}, kwargs: {kwargs}")
+            
+            try:
+                result = await func(*args, **kwargs)
+                execution_time = time.time() - start_time
+                logger.debug(f"Completed async {func.__name__} in {execution_time:.2f} seconds")
+                return result
+            except Exception as e:
+                logger.error(f"Error in async {func.__name__}: {str(e)}", exc_info=True)
+                raise
+        return wrapper
+    return decorator

requirements.txt

@@ -0,0 +1,38 @@
+# Core AI and Language Models
+langchain-openai>=0.0.1
+langchain-google-genai>=0.0.1
+langchain-anthropic>=0.0.1
+langchain-ollama>=0.0.1
+
+# Web and Browser Automation
+playwright>=1.40.0
+browser-use>=0.1.20
+aiohttp>=3.8.0
+requests>=2.31.0
+
+# Audio Generation
+elevenlabs>=0.1.0
+
+# Data Handling and Validation
+pydantic>=2.0.0
+dataclasses>=0.6
+typing-extensions>=4.8.0
+
+# Configuration and Environment
+python-dotenv>=1.0.0
+
+# Error Handling and Logging
+python-json-logger>=2.0.0  # Structured JSON logging
+rich>=13.0.0  # For console output formatting
+backoff>=2.2.0  # Retry mechanism
+tenacity>=8.2.0  # Retry utilities
+
+# UI and Interface
+gradio>=4.0.0  # For better themes and UI components
+
+# Async Support
+asyncio>=3.4.3
+
+# Testing and Development
+pytest>=7.0.0  # For running tests
+mypy>=1.0.0   # For type checking

setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="podcaster",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=[
+        'rich',
+        # add other dependencies here
+    ]
+)