Audio Overview Generation

def get_audio_overview_crew():
    # Research Analyst
    research_analyst = Agent(
        name="Research Analyst",
        role="Content Analyst",
        goal="Extract and organize key insights from research content",
        backstory="""You are an expert research analyst who excels at 
                     distilling complex information into clear, actionable 
                     summaries while maintaining accuracy.""",
        llm=llm,
        verbose=True
    )
    
    # Conversation Planner
    conversation_planner = Agent(
        name="Conversation Planner",
        role="Podcast Producer",
        goal="Structure research insights into engaging podcast conversation",
        backstory="""You are a podcast producer who specializes in 
                     transforming complex topics into natural, flowing 
                     conversations that educate and engage.""",
        llm=llm,
        verbose=True
    )
    
    # Script Writer
    script_writer = Agent(
        name="Script Writer",
        role="Podcast Scriptwriter",
        goal="Write natural podcast dialogue",
        backstory="""You are a scriptwriter who excels at crafting 
                     authentic podcast conversations that balance education 
                     with entertainment.""",
        llm=llm,
        verbose=True
    )

class AudioOverviewTranscript(BaseModel):
    transcript: List[TranscriptSegment]

class TranscriptSegment(BaseModel):
    name: str      # "Michael" or "Sarah"
    transcript: str  # Dialogue text

[
    {"name": "Michael", "transcript": "Welcome to The DecipherIt Podcast..."},
    {"name": "Sarah", "transcript": "Thanks for having me, Michael..."},
    {"name": "Michael", "transcript": "So let's dive into the research..."}
]

class TTSService:
    def __init__(self):
        self.api_key = os.environ.get("LEMONFOX_API_KEY")
        self.base_url = "https://api.lemonfox.ai/v1/audio/speech"
        self.response_format = "mp3"
        
        # Voice mapping
        self.speaker_voices = {
            "Michael": "liam",    # Host voice
            "Sarah": "jessica"    # Guest voice
        }
        
        # Performance settings
        self.pause_duration = 500  # 0.5 seconds between segments
        self.max_concurrent_requests = 5
        self.semaphore = asyncio.Semaphore(self.max_concurrent_requests)

async def generate_audio_from_transcript(
    self,
    transcript: List[Dict[str, Any]],
    notebook_id: str
) -> bytes:
    # Process segments concurrently with semaphore for rate limiting
    tasks = []
    for i, segment in enumerate(valid_segments):
        speaker = segment.get("name", "Michael")
        text = segment.get("transcript", "")
        voice = self.speaker_voices.get(speaker, "jessica")
        
        task = self._generate_audio_with_semaphore(
            text, voice, i + 1, len(transcript)
        )
        tasks.append(task)
    
    # Execute all TTS requests concurrently
    audio_bytes_list = await asyncio.gather(*tasks, return_exceptions=True)
    
    # Combine audio segments
    return await self._combine_audio_segments(audio_bytes_list, valid_segments)

async def _combine_audio_segments(
    self,
    audio_bytes_list: List[bytes],
    valid_segments: List[tuple]
) -> bytes:
    combined_audio = None
    
    for i, audio_bytes in enumerate(audio_bytes_list):
        async with self._audio_segment_context(audio_bytes) as segment_audio:
            if combined_audio is None:
                combined_audio = segment_audio
            else:
                combined_audio += segment_audio
            
            # Add pause between segments (except for the last one)
            if i < len(audio_bytes_list) - 1:
                pause = AudioSegment.silent(duration=self.pause_duration)
                combined_audio += pause
    
    # Export to MP3
    output_buffer = io.BytesIO()
    combined_audio.export(output_buffer, format="mp3")
    return output_buffer.getvalue()

const [audioOverviewUrl, setAudioOverviewUrl] = useState<string | null>(
  initialAudioOverviewUrl || null
);

// Status values:
// - null: Not generated yet
// - "IN_PROGRESS": Currently generating
// - "ERROR": Generation failed
// - "https://...": Audio URL (success)

useEffect(() => {
  if (audioOverviewUrl !== "IN_PROGRESS") {
    return;
  }
  
  const pollInterval = setInterval(async () => {
    const response = await fetch(`/api/notebooks/${notebookId}`);
    const notebook = await response.json();
    const newAudioUrl = notebook.output?.audioOverviewUrl;
    
    if (newAudioUrl && newAudioUrl !== "IN_PROGRESS") {
      setAudioOverviewUrl(newAudioUrl);
      
      if (newAudioUrl === "ERROR") {
        toast.error("Audio overview generation failed");
      } else {
        toast.success("Audio overview ready!");
      }
    }
  }, 3000); // Poll every 3 seconds
  
  return () => clearInterval(pollInterval);
}, [audioOverviewUrl, notebookId]);

async def _get_client(self) -> httpx.AsyncClient:
    """Get or create HTTP client with connection pooling."""
    if self._client is None or self._client.is_closed:
        async with self._client_lock:
            limits = httpx.Limits(
                max_keepalive_connections=10,
                max_connections=20,
                keepalive_expiry=30.0
            )
            self._client = httpx.AsyncClient(
                timeout=httpx.Timeout(300.0),  # 5 minute timeout
                limits=limits,
                http2=True
            )
    return self._client

self.semaphore = asyncio.Semaphore(self.max_concurrent_requests)

async def _generate_audio_with_semaphore(
    self,
    text: str,
    voice: str,
    segment_num: int,
    total_segments: int
) -> bytes:
    async with self.semaphore:
        return await self._generate_audio(text, voice)