Update utils.py

utils.py

@@ -14,12 +14,7 @@ import numpy as np
 import torch
 import logging
 
-# Configure Logging
-logging.basicConfig(
-    filename="debug.log",
-    level=logging.DEBUG,
-    format="%(asctime)s - %(levelname)s - %(message)s"
-)
+logging.basicConfig(filename="debug.log", level=logging.DEBUG)
 
 class DialogueItem(BaseModel):
     speaker: Literal["Jane", "John"]
@@ -39,109 +34,63 @@ def extract_text_from_url(url):
     try:
         response = requests.get(url, headers=headers)
         response.raise_for_status()
-
         soup = BeautifulSoup(response.text, 'html.parser')
         for script in soup(["script", "style"]):
             script.decompose()
-
-        text = soup.get_text(separator=' ')
-        return text.strip() if text else "No readable content extracted."
+        return soup.get_text(separator=' ').strip()
     
     except requests.exceptions.RequestException as e:
         logging.error(f"Error extracting text from URL: {str(e)}")
         return f"Failed to extract text from URL: {str(e)}"
 
-def generate_script(prompt, text, tone, length, host_name, guest_name, sponsor_style, sponsor_provided):
+def transcribe_youtube_video(video_url):
     """
-    Calls the LLM to generate a structured podcast script from research text.
+    Uses yt-dlp to extract audio from a YouTube video and transcribe it.
     """
-    groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+    temp_audio_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+        'outtmpl': temp_audio_file.name,
+    }
 
     try:
-        logging.info("Calling LLM for script generation.")
-        response = groq_client.chat.completions.create(
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": text}
-            ],
-            model="DeepSeek-R1-Distill-Llama-70B",
-            max_tokens=4096,
-            temperature=0.6
-        )
-
-        if not response.choices or not response.choices[0].message.content:
-            logging.error("LLM returned an empty response. Retrying with fallback prompt...")
-            return Dialogue(dialogue=[DialogueItem(speaker="Jane", display_speaker="Jane", text="Sorry, no data available.")])
-
-        script_content = response.choices[0].message.content.strip()
-        dialogue_items = parse_script_to_dialogue(script_content, host_name, guest_name)
-
-        if not dialogue_items:
-            raise ValueError("Script parsing failed. No valid dialogue found.")
-
-        return Dialogue(dialogue=dialogue_items)
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([video_url])
+        
+        return transcribe_audio(temp_audio_file.name)
 
     except Exception as e:
-        logging.error(f"Failed to generate script: {str(e)}")
-        return Dialogue(dialogue=[DialogueItem(speaker="Jane", display_speaker="Jane", text="I'm sorry, something went wrong.")])
-
-def truncate_text(text, max_tokens=2048):
-    """
-    Truncates input text to ensure it doesn't exceed token limits.
-    """
-    tokenizer = tiktoken.get_encoding("cl100k_base")
-    tokens = tokenizer.encode(text)
-
-    if len(tokens) > max_tokens:
-        return tokenizer.decode(tokens[:max_tokens])
-    
-    return text
+        logging.error(f"Error downloading/transcribing YouTube video: {str(e)}")
+        return f"Error processing YouTube video: {str(e)}"
 
-def generate_audio_mp3(text, speaker):
+def transcribe_audio(file_path):
     """
-    Uses Groq's LLM to generate realistic text-to-speech (TTS) audio.
+    Uses Deepgram API to transcribe audio.
     """
-    groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-    response = groq_client.chat.completions.create(
-        messages=[{"role": "system", "content": f"Generate a realistic voice for {speaker}: {text}"}],
-        model="llama-3.3-70b-versatile",
-        max_tokens=512,
-        temperature=0.6
-    )
+    DEEPGRAM_API_KEY = os.environ.get("DEEPGRAM_API_KEY")
+    if not DEEPGRAM_API_KEY:
+        logging.error("Deepgram API key is missing.")
+        return "Deepgram API key is missing."
 
-    speech_text = response.choices[0].message.content.strip()
-    temp_audio = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+    url = "https://api.deepgram.com/v1/listen?model=nova-2&smart_format=true"
+    headers = {
+        "Authorization": f"Token {DEEPGRAM_API_KEY}",
+        "Content-Type": "audio/mpeg"
+    }
 
     try:
-        temp_audio.write(speech_text.encode('utf-8'))
-        temp_audio.close()
-
-        # ✅ Verify MP3 File Integrity Before Returning
-        audio_test = AudioSegment.from_file(temp_audio.name, format="mp3")
-        if len(audio_test) == 0:
-            raise ValueError("Generated MP3 file is empty or corrupted.")
-
-        return temp_audio.name
-    
-    except Exception as e:
-        logging.error(f"Failed to generate MP3 file: {str(e)}")
+        with open(file_path, "rb") as f:
+            response = requests.post(url, headers=headers, data=f)
 
-        # ✅ Fallback: Generate a silent MP3 file to prevent ffmpeg crashes
-        silent_audio = AudioSegment.silent(duration=2000)  # 2 seconds of silence
-        fallback_mp3 = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
-        silent_audio.export(fallback_mp3.name, format="mp3")
-        return fallback_mp3.name
-
-def research_topic(topic: str) -> str:
-    """
-    Uses Open Deep Researcher to fetch the latest web-based research.
-    """
-    from run_agents import run_deep_research_agent  # Ensure Open Deep Researcher is connected.
+        response.raise_for_status()
+        data = response.json()
+        return data["results"]["channels"][0]["alternatives"][0].get("transcript", "")
 
-    try:
-        logging.info(f"Running Open Deep Researcher for topic: {topic}")
-        research_result = run_deep_research_agent(topic)
-        return research_result if research_result else f"No new information found for '{topic}'."
     except Exception as e:
-        logging.error(f"Error during research: {str(e)}")
-        return f"Error during research: {str(e)}"
+        logging.error(f"Error transcribing audio: {str(e)}")
+        return f"Error transcribing audio: {str(e)}"