Chore: Clean up code (#2)

app.py

@@ -8,69 +8,48 @@ import os
 import time
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import List, Literal, Tuple, Optional
+from typing import List, Tuple, Optional
 
 # Third-party imports
 import gradio as gr
+import random
 from loguru import logger
-from pydantic import BaseModel, Field
 from pypdf import PdfReader
 from pydub import AudioSegment
 
 # Local imports
-from prompts import SYSTEM_PROMPT
-from utils import generate_script, generate_podcast_audio, parse_url
-
-
-class DialogueItem(BaseModel):
-    """A single dialogue item."""
-
-    speaker: Literal["Host (Jane)", "Guest"]
-    text: str
-
-
-class ShortDialogue(BaseModel):
-    """The dialogue between the host and guest."""
-
-    scratchpad: str
-    name_of_guest: str
-    dialogue: List[DialogueItem] = Field(..., description="A list of dialogue items, typically between 5 to 9 items")
-
-
-class MediumDialogue(BaseModel):
-    """The dialogue between the host and guest."""
-
-    scratchpad: str
-    name_of_guest: str
-    dialogue: List[DialogueItem] = Field(..., description="A list of dialogue items, typically between 8 to 13 items")
-
-
-LANGUAGE_MAPPING = {
-    "English": "en",
-    "Chinese": "zh",
-    "French": "fr",
-    "German": "de",
-    "Hindi": "hi",
-    "Italian": "it",
-    "Japanese": "ja",
-    "Korean": "ko",
-    "Polish": "pl",
-    "Portuguese": "pt",
-    "Russian": "ru",
-    "Spanish": "es",
-    "Turkish": "tr"
-}
-
-MELO_TTS_LANGUAGE_MAPPING = {
-    "en": "EN",
-    "es": "ES",
-    "fr": "FR",
-    "zh": "ZJ",
-    "ja": "JP",
-    "ko": "KR",
-}
-
-
+from constants import (
+    APP_TITLE,
+    CHARACTER_LIMIT,
+    ERROR_MESSAGE_NOT_PDF,
+    ERROR_MESSAGE_NO_INPUT,
+    ERROR_MESSAGE_NOT_SUPPORTED_IN_MELO_TTS,
+    ERROR_MESSAGE_READING_PDF,
+    ERROR_MESSAGE_TOO_LONG,
+    GRADIO_CACHE_DIR,
+    GRADIO_CLEAR_CACHE_OLDER_THAN,
+    MELO_TTS_LANGUAGE_MAPPING,
+    NOT_SUPPORTED_IN_MELO_TTS,
+    SUNO_LANGUAGE_MAPPING,
+    UI_ALLOW_FLAGGING,
+    UI_API_NAME,
+    UI_CACHE_EXAMPLES,
+    UI_CONCURRENCY_LIMIT,
+    UI_DESCRIPTION,
+    UI_EXAMPLES,
+    UI_INPUTS,
+    UI_OUTPUTS,
+    UI_SHOW_API,
+)
+from prompts import (
+    LANGUAGE_MODIFIER,
+    LENGTH_MODIFIERS,
+    QUESTION_MODIFIER,
+    SYSTEM_PROMPT,
+    TONE_MODIFIER,
+)
+from schema import ShortDialogue, MediumDialogue
+from utils import generate_podcast_audio, generate_script, parse_url
 
 
 def generate_podcast(
@@ -84,32 +63,30 @@ def generate_podcast(
 ) -> Tuple[str, str]:
     """Generate the audio and transcript from the PDFs and/or URL."""
 
-
-
     text = ""
 
-    # Check if the selected language is supported by MeloTTS when not using advanced audio
-    if not use_advanced_audio and language in ['German', 'Hindi', 'Italian', 'Polish', 'Portuguese', 'Russian', 'Turkish']:
-        raise gr.Error(f"The selected language '{language}' is not supported without advanced audio generation. Please enable advanced audio generation or choose a supported language.")
+    # Choose random number from 0 to 9
+    random_voice_number = random.randint(0, 9) # this is for suno model
+
+    if not use_advanced_audio and language in NOT_SUPPORTED_IN_MELO_TTS:
+        raise gr.Error(ERROR_MESSAGE_NOT_SUPPORTED_IN_MELO_TTS)
 
     # Check if at least one input is provided
     if not files and not url:
-        raise gr.Error("Please provide at least one PDF file or a URL.")
+        raise gr.Error(ERROR_MESSAGE_NO_INPUT)
 
     # Process PDFs if any
     if files:
         for file in files:
             if not file.lower().endswith(".pdf"):
-                raise gr.Error(
-                    f"File {file} is not a PDF. Please upload only PDF files."
-                )
+                raise gr.Error(ERROR_MESSAGE_NOT_PDF)
 
             try:
                 with Path(file).open("rb") as f:
                     reader = PdfReader(f)
                     text += "\n\n".join([page.extract_text() for page in reader.pages])
             except Exception as e:
-                raise gr.Error(f"Error reading the PDF file {file}: {str(e)}")
+                raise gr.Error(f"{ERROR_MESSAGE_READING_PDF}: {str(e)}")
 
     # Process URL if provided
     if url:
@@ -120,34 +97,27 @@ def generate_podcast(
             raise gr.Error(str(e))
 
     # Check total character count
-    if len(text) > 100000:
-        raise gr.Error(
-            "The total content is too long. Please ensure the combined text from PDFs and URL is fewer than ~100,000 characters."
-        )
-    
+    if len(text) > CHARACTER_LIMIT:
+        raise gr.Error(ERROR_MESSAGE_TOO_LONG)
 
     # Modify the system prompt based on the user input
     modified_system_prompt = SYSTEM_PROMPT
+
     if question:
-        modified_system_prompt += f"\n\PLEASE ANSWER THE FOLLOWING QN: {question}"
+        modified_system_prompt += f"\n\n{QUESTION_MODIFIER} {question}"
     if tone:
-        modified_system_prompt += f"\n\nTONE: The tone of the podcast should be {tone}."
+        modified_system_prompt += f"\n\n{TONE_MODIFIER} {tone}."
     if length:
-        length_instructions = {
-            "Short (1-2 min)": "Keep the podcast brief, around 1-2 minutes long.",
-            "Medium (3-5 min)": "Aim for a moderate length, about 3-5 minutes.",
-        }
-        modified_system_prompt += f"\n\nLENGTH: {length_instructions[length]}"
+        modified_system_prompt += f"\n\n{LENGTH_MODIFIERS[length]}"
     if language:
-        modified_system_prompt += (
-            f"\n\nOUTPUT LANGUAGE <IMPORTANT>: The the podcast should be {language}."
-        )
+        modified_system_prompt += f"\n\n{LANGUAGE_MODIFIER} {language}."
 
     # Call the LLM
     if length == "Short (1-2 min)":
         llm_output = generate_script(modified_system_prompt, text, ShortDialogue)
     else:
         llm_output = generate_script(modified_system_prompt, text, MediumDialogue)
+
     logger.info(f"Generated dialogue: {llm_output}")
 
     # Process the dialogue
@@ -164,14 +134,14 @@ def generate_podcast(
         transcript += speaker + "\n\n"
         total_characters += len(line.text)
 
-        language_for_tts = LANGUAGE_MAPPING[language]
+        language_for_tts = SUNO_LANGUAGE_MAPPING[language]
 
         if not use_advanced_audio:
             language_for_tts = MELO_TTS_LANGUAGE_MAPPING[language_for_tts]
 
         # Get audio file path
         audio_file_path = generate_podcast_audio(
-            line.text, line.speaker, language_for_tts, use_advanced_audio
+            line.text, line.speaker, language_for_tts, use_advanced_audio, random_voice_number
         )
         # Read the audio file into an AudioSegment
         audio_segment = AudioSegment.from_file(audio_file_path)
@@ -181,7 +151,7 @@ def generate_podcast(
     combined_audio = sum(audio_segments)
 
     # Export the combined audio to a temporary file
-    temporary_directory = "./gradio_cached_examples/tmp/"
+    temporary_directory = GRADIO_CACHE_DIR
     os.makedirs(temporary_directory, exist_ok=True)
 
     temporary_file = NamedTemporaryFile(
@@ -193,7 +163,10 @@ def generate_podcast(
 
     # Delete any files in the temp directory that end with .mp3 and are over a day old
     for file in glob.glob(f"{temporary_directory}*.mp3"):
-        if os.path.isfile(file) and time.time() - os.path.getmtime(file) > 24 * 60 * 60:
+        if (
+            os.path.isfile(file)
+            and time.time() - os.path.getmtime(file) > GRADIO_CLEAR_CACHE_OLDER_THAN
+        ):
             os.remove(file)
 
     logger.info(f"Generated {total_characters} characters of audio")
@@ -202,90 +175,53 @@ def generate_podcast(
 
 
 demo = gr.Interface(
-    title="Open NotebookLM",
-    description="""
-
-<table style="border-collapse: collapse; border: none; padding: 20px;">
-  <tr style="border: none;">
-    <td style="border: none; vertical-align: top; padding-right: 30px; padding-left: 30px;">
-      <img src="https://raw.githubusercontent.com/gabrielchua/daily-ai-papers/main/_includes/icon.png" alt="Open NotebookLM" width="120" style="margin-bottom: 10px;">
-    </td>
-    <td style="border: none; vertical-align: top; padding: 10px;">
-      <p style="margin-bottom: 15px;"><strong>Convert</strong> your PDFs into podcasts with open-source AI models (Llama 3.1 405B and MeloTTS).</p>
-      <p style="margin-top: 15px;">Note: Only the text content of the PDFs will be processed. Images and tables are not included. The total content should be no more than 100,000 characters due to the context length of Llama 3.1 405B.</p>
-    </td>
-  </tr>
-</table>
-""",
+    title=APP_TITLE,
+    description=UI_DESCRIPTION,
     fn=generate_podcast,
     inputs=[
         gr.File(
-            label="1. 📄 Upload your PDF(s)", file_types=[".pdf"], file_count="multiple"
+            label=UI_INPUTS["file_upload"]["label"],  # Step 1: File upload
+            file_types=UI_INPUTS["file_upload"]["file_types"],
+            file_count=UI_INPUTS["file_upload"]["file_count"],
         ),
         gr.Textbox(
-            label="2. 🔗 Paste a URL (optional)",
-            placeholder="Enter a URL to include its content",
+            label=UI_INPUTS["url"]["label"],  # Step 2: URL
+            placeholder=UI_INPUTS["url"]["placeholder"],
         ),
-        gr.Textbox(label="3. 🤔 Do you have a specific question or topic in mind?"),
+        gr.Textbox(label=UI_INPUTS["question"]["label"]),  # Step 3: Question
         gr.Dropdown(
-            choices=["Fun", "Formal"],
-            label="4. 🎭 Choose the tone",
-            value="Fun"
+            label=UI_INPUTS["tone"]["label"],  # Step 4: Tone
+            choices=UI_INPUTS["tone"]["choices"],
+            value=UI_INPUTS["tone"]["value"],
         ),
         gr.Dropdown(
-            choices=["Short (1-2 min)", "Medium (3-5 min)"],
-            label="5. ⏱️ Choose the length",
-            value="Medium (3-5 min)"
+            label=UI_INPUTS["length"]["label"],  # Step 5: Length
+            choices=UI_INPUTS["length"]["choices"],
+            value=UI_INPUTS["length"]["value"],
         ),
         gr.Dropdown(
-            choices=list(LANGUAGE_MAPPING.keys()),
-            value="English",
-            label="6. 🌐 Choose the language"
+            choices=UI_INPUTS["language"]["choices"],  # Step 6: Language
+            value=UI_INPUTS["language"]["value"],
+            label=UI_INPUTS["language"]["label"],
         ),
         gr.Checkbox(
-            label="7. 🔄 Use advanced audio generation? (Experimental)",
-            value=False
-        )
+            label=UI_INPUTS["advanced_audio"]["label"],
+            value=UI_INPUTS["advanced_audio"]["value"],
+        ),
     ],
     outputs=[
-        gr.Audio(label="Podcast", format="mp3"),
-        gr.Markdown(label="Transcript"),
+        gr.Audio(
+            label=UI_OUTPUTS["audio"]["label"], format=UI_OUTPUTS["audio"]["format"]
+        ),
+        gr.Markdown(label=UI_OUTPUTS["transcript"]["label"]),
     ],
-    allow_flagging="never",
-    api_name="generate_podcast",
+    allow_flagging=UI_ALLOW_FLAGGING,
+    api_name=UI_API_NAME,
     theme=gr.themes.Soft(),
-    concurrency_limit=3,
-    examples=[
-        [
-            [str(Path("examples/1310.4546v1.pdf"))],
-            "",
-            "Explain this paper to me like I'm 5 years old",
-            "Fun",
-            "Short (1-2 min)",
-            "English",
-            True
-        ],
-        [
-            [],
-            "https://en.wikipedia.org/wiki/Hugging_Face",
-            "How did Hugging Face become so successful?",
-            "Fun",
-            "Short (1-2 min)",
-            "English",
-            False
-        ],
-        [
-            [],
-            "https://simple.wikipedia.org/wiki/Taylor_Swift",
-            "Why is Taylor Swift so popular?",
-            "Fun",
-            "Short (1-2 min)",
-            "English",
-            False
-        ],
-    ],
-    cache_examples=True,
+    concurrency_limit=UI_CONCURRENCY_LIMIT,
+    # examples=UI_EXAMPLES,
+    # cache_examples=UI_CACHE_EXAMPLES,
 )
 
 if __name__ == "__main__":
-    demo.launch(show_api=True)
+    demo.launch(show_api=UI_SHOW_API)

constants.py

@@ -0,0 +1,166 @@
+"""
+constants.py
+"""
+
+import os
+
+from pathlib import Path
+
+# Key constants
+APP_TITLE = "Open NotebookLM"
+CHARACTER_LIMIT = 100_000
+
+# Gradio-related constants
+GRADIO_CACHE_DIR = "./gradio_cached_examples/tmp/"
+GRADIO_CLEAR_CACHE_OLDER_THAN = 1 * 24 * 60 * 60  # 1 day
+
+# Error messages-related constants
+ERROR_MESSAGE_NO_INPUT = "Please provide at least one PDF file or a URL."
+ERROR_MESSAGE_NOT_PDF = "The provided file is not a PDF. Please upload only PDF files."
+ERROR_MESSAGE_NOT_SUPPORTED_IN_MELO_TTS = "The selected language is not supported without advanced audio generation. Please enable advanced audio generation or choose a supported language."
+ERROR_MESSAGE_READING_PDF = "Error reading the PDF file"
+ERROR_MESSAGE_TOO_LONG = "The total content is too long. Please ensure the combined text from PDFs and URL is fewer than {CHARACTER_LIMIT} characters."
+
+# Fireworks API-related constants
+FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY")
+FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1"
+FIREWORKS_MAX_TOKENS = 16_384
+FIREWORKS_MODEL_ID = "accounts/fireworks/models/llama-v3p1-405b-instruct"
+FIREWORKS_TEMPERATURE = 0.1
+FIREWORKS_JSON_RETRY_ATTEMPTS = 3
+
+# MeloTTS
+MELO_API_NAME = "/synthesize"
+MELO_TTS_SPACES_ID = "mrfakename/MeloTTS"
+MELO_RETRY_ATTEMPTS = 3
+MELO_RETRY_DELAY = 5  # in seconds
+
+MELO_TTS_LANGUAGE_MAPPING = {
+    "en": "EN",
+    "es": "ES",
+    "fr": "FR",
+    "zh": "ZJ",
+    "ja": "JP",
+    "ko": "KR",
+}
+
+
+# Suno related constants
+SUNO_LANGUAGE_MAPPING = {
+    "English": "en",
+    "Chinese": "zh",
+    "French": "fr",
+    "German": "de",
+    "Hindi": "hi",
+    "Italian": "it",
+    "Japanese": "ja",
+    "Korean": "ko",
+    "Polish": "pl",
+    "Portuguese": "pt",
+    "Russian": "ru",
+    "Spanish": "es",
+    "Turkish": "tr",
+}
+
+# General audio-related constants
+NOT_SUPPORTED_IN_MELO_TTS = list(
+    set(SUNO_LANGUAGE_MAPPING.values()) - set(MELO_TTS_LANGUAGE_MAPPING.keys())
+)
+NOT_SUPPORTED_IN_MELO_TTS = [
+    key for key, id in SUNO_LANGUAGE_MAPPING.items() if id in NOT_SUPPORTED_IN_MELO_TTS
+]
+
+# Jina Reader-related constants
+JINA_READER_URL = "https://r.jina.ai/"
+JINA_RETRY_ATTEMPTS = 3
+JINA_RETRY_DELAY = 5  # in seconds
+
+# UI-related constants
+UI_DESCRIPTION = """
+<table style="border-collapse: collapse; border: none; padding: 20px;">
+  <tr style="border: none;">
+    <td style="border: none; vertical-align: top; padding-right: 30px; padding-left: 30px;">
+      <img src="https://raw.githubusercontent.com/gabrielchua/daily-ai-papers/main/_includes/icon.png" alt="Open NotebookLM" width="120" style="margin-bottom: 10px;">
+    </td>
+    <td style="border: none; vertical-align: top; padding: 10px;">
+      <p style="margin-bottom: 15px;">Convert your PDFs into podcasts with open-source AI models (<a href="https://huggingface.co/meta-llama/Llama-3.1-405B">Llama 3.1 405B</a>, <a href="https://huggingface.co/myshell-ai/MeloTTS-English">MeloTTS</a>, <a href="https://huggingface.co/suno/bark">Bark</a>).</p>
+      <p style="margin-top: 15px;">Note: Only the text content of the PDFs will be processed. Images and tables are not included. The total content should be no more than 100,000 characters due to the context length of Llama 3.1 405B.</p>
+    </td>
+  </tr>
+</table>
+"""
+UI_AVAILABLE_LANGUAGES = list(set(SUNO_LANGUAGE_MAPPING.keys()))
+UI_INPUTS = {
+    "file_upload": {
+        "label": "1. 📄 Upload your PDF(s)",
+        "file_types": [".pdf"],
+        "file_count": "multiple",
+    },
+    "url": {
+        "label": "2. 🔗 Paste a URL (optional)",
+        "placeholder": "Enter a URL to include its content",
+    },
+    "question": {
+        "label": "3. 🤔 Do you have a specific question or topic in mind?",
+        "placeholder": "Enter a question or topic",
+    },
+    "tone": {
+        "label": "4. 🎭 Choose the tone",
+        "choices": ["Fun", "Formal"],
+        "value": "Fun",
+    },
+    "length": {
+        "label": "5. ⏱️ Choose the length",
+        "choices": ["Short (1-2 min)", "Medium (3-5 min)"],
+        "value": "Medium (3-5 min)",
+    },
+    "language": {
+        "label": "6. 🌐 Choose the language",
+        "choices": UI_AVAILABLE_LANGUAGES,
+        "value": "English",
+    },
+    "advanced_audio": {
+        "label": "7. 🔄 Use advanced audio generation? (Experimental)",
+        "value": False,
+    },
+}
+UI_OUTPUTS = {
+    "audio": {"label": "🔊 Podcast", "format": "mp3"},
+    "transcript": {
+        "label": "📜 Transcript",
+    },
+}
+UI_API_NAME = "generate_podcast"
+UI_ALLOW_FLAGGING = "never"
+UI_CONCURRENCY_LIMIT = 3
+UI_EXAMPLES = [
+    [
+        [str(Path("examples/1310.4546v1.pdf"))],
+        "",
+        "Explain this paper to me like I'm 5 years old",
+        "Fun",
+        "Short (1-2 min)",
+        "English",
+        True,
+    ],
+    [
+        [],
+        "https://en.wikipedia.org/wiki/Hugging_Face",
+        "How did Hugging Face become so successful?",
+        "Fun",
+        "Short (1-2 min)",
+        "English",
+        False,
+    ],
+    [
+        [],
+        "https://simple.wikipedia.org/wiki/Taylor_Swift",
+        "Why is Taylor Swift so popular?",
+        "Fun",
+        "Short (1-2 min)",
+        "English",
+        False,
+    ],
+]
+UI_CACHE_EXAMPLES = True
+UI_SHOW_API = True

prompts.py

@@ -51,5 +51,18 @@ You are a world-class podcast producer tasked with transforming the provided inp
    - Include brief "breather" moments for listeners to absorb complex information
    - End on a high note, perhaps with a thought-provoking question or a call-to-action for listeners
 
+IMPORTANT RULE: Each line of dialogue should be no more than 100 characters (e.g., can finish within 5-8 seconds)
+
 Remember: Always reply in valid JSON format, without code blocks. Begin directly with the JSON output.
 """
+
+QUESTION_MODIFIER = "PLEASE ANSWER THE FOLLOWING QN:"
+
+TONE_MODIFIER = "TONE: The tone of the podcast should be"
+
+LANGUAGE_MODIFIER = "OUTPUT LANGUAGE <IMPORTANT>: The the podcast should be"
+
+LENGTH_MODIFIERS = {
+    "Short (1-2 min)": "Keep the podcast brief, around 1-2 minutes long.",
+    "Medium (3-5 min)": "Aim for a moderate length, about 3-5 minutes.",
+}

schema.py

@@ -0,0 +1,34 @@
+"""
+schema.py
+"""
+
+from typing import Literal, List
+
+from pydantic import BaseModel, Field
+
+
+class DialogueItem(BaseModel):
+    """A single dialogue item."""
+
+    speaker: Literal["Host (Jane)", "Guest"]
+    text: str
+
+
+class ShortDialogue(BaseModel):
+    """The dialogue between the host and guest."""
+
+    scratchpad: str
+    name_of_guest: str
+    dialogue: List[DialogueItem] = Field(
+        ..., description="A list of dialogue items, typically between 11 to 17 items"
+    )
+
+
+class MediumDialogue(BaseModel):
+    """The dialogue between the host and guest."""
+
+    scratchpad: str
+    name_of_guest: str
+    dialogue: List[DialogueItem] = Field(
+        ..., description="A list of dialogue items, typically between 19 to 29 items"
+    )

utils.py

@@ -2,68 +2,115 @@
 utils.py
 
 Functions:
-- get_script: Get the dialogue from the LLM.
+- generate_script: Get the dialogue from the LLM.
 - call_llm: Call the LLM with the given prompt and dialogue format.
-- get_audio: Get the audio from the TTS model from HF Spaces.
+- parse_url: Parse the given URL and return the text content.
+- generate_podcast_audio: Generate audio for podcast using TTS or advanced audio models.
 """
 
-import os
-import requests
+# Standard library imports
 import time
+from typing import Any, Union
+
+# Third-party imports
+import requests
+from bark import SAMPLE_RATE, generate_audio, preload_models
 from gradio_client import Client
 from openai import OpenAI
 from pydantic import ValidationError
-
-from bark import SAMPLE_RATE, generate_audio, preload_models
 from scipy.io.wavfile import write as write_wav
 
-MODEL_ID = "accounts/fireworks/models/llama-v3p1-405b-instruct"
-JINA_URL = "https://r.jina.ai/"
-
-client = OpenAI(
-    base_url="https://api.fireworks.ai/inference/v1",
-    api_key=os.getenv("FIREWORKS_API_KEY"),
+# Local imports
+from constants import (
+    FIREWORKS_API_KEY,
+    FIREWORKS_BASE_URL,
+    FIREWORKS_MODEL_ID,
+    FIREWORKS_MAX_TOKENS,
+    FIREWORKS_TEMPERATURE,
+    FIREWORKS_JSON_RETRY_ATTEMPTS,
+    MELO_API_NAME,
+    MELO_TTS_SPACES_ID,
+    MELO_RETRY_ATTEMPTS,
+    MELO_RETRY_DELAY,
+    JINA_READER_URL,
+    JINA_RETRY_ATTEMPTS,
+    JINA_RETRY_DELAY,
 )
+from schema import ShortDialogue, MediumDialogue
 
-hf_client = Client("mrfakename/MeloTTS")
+# Initialize clients
+fw_client = OpenAI(base_url=FIREWORKS_BASE_URL, api_key=FIREWORKS_API_KEY)
+hf_client = Client(MELO_TTS_SPACES_ID)
 
-# download and load all models
+# Download and load all models for Bark
 preload_models()
 
 
-def generate_script(system_prompt: str, input_text: str, output_model):
+def generate_script(
+    system_prompt: str,
+    input_text: str,
+    output_model: Union[ShortDialogue, MediumDialogue],
+) -> Union[ShortDialogue, MediumDialogue]:
     """Get the dialogue from the LLM."""
-    # Load as python object
-    try:
-        response = call_llm(system_prompt, input_text, output_model)
-        dialogue = output_model.model_validate_json(response.choices[0].message.content)
-    except ValidationError as e:
-        error_message = f"Failed to parse dialogue JSON: {e}"
-        system_prompt_with_error = f"{system_prompt}\n\nPlease return a VALID JSON object. This was the earlier error: {error_message}"
-        response = call_llm(system_prompt_with_error, input_text, output_model)
-        dialogue = output_model.model_validate_json(response.choices[0].message.content)
-
-    # Call the LLM again to improve the dialogue
-    system_prompt_with_dialogue = f"{system_prompt}\n\nHere is the first draft of the dialogue you provided:\n\n{dialogue}."
-    response = call_llm(
-        system_prompt_with_dialogue, "Please improve the dialogue.", output_model
-    )
-    improved_dialogue = output_model.model_validate_json(
-        response.choices[0].message.content
-    )
-    return improved_dialogue
 
-
-def call_llm(system_prompt: str, text: str, dialogue_format):
+    # Call the LLM
+    response = call_llm(system_prompt, input_text, output_model)
+    response_json = response.choices[0].message.content
+
+    # Validate the response
+    for attempt in range(FIREWORKS_JSON_RETRY_ATTEMPTS):
+        try:
+            first_draft_dialogue = output_model.model_validate_json(response_json)
+            break
+        except ValidationError as e:
+            if attempt == FIREWORKS_JSON_RETRY_ATTEMPTS - 1:  # Last attempt
+                raise ValueError(
+                    f"Failed to parse dialogue JSON after {FIREWORKS_JSON_RETRY_ATTEMPTS} attempts: {e}"
+                ) from e
+            error_message = (
+                f"Failed to parse dialogue JSON (attempt {attempt + 1}): {e}"
+            )
+            # Re-call the LLM with the error message
+            system_prompt_with_error = f"{system_prompt}\n\nPlease return a VALID JSON object. This was the earlier error: {error_message}"
+            response = call_llm(system_prompt_with_error, input_text, output_model)
+            response_json = response.choices[0].message.content
+            first_draft_dialogue = output_model.model_validate_json(response_json)
+
+    # Call the LLM a second time to improve the dialogue
+    system_prompt_with_dialogue = f"{system_prompt}\n\nHere is the first draft of the dialogue you provided:\n\n{first_draft_dialogue}."
+
+    # Validate the response
+    for attempt in range(FIREWORKS_JSON_RETRY_ATTEMPTS):
+        try:
+            response = call_llm(
+                system_prompt_with_dialogue,
+                "Please improve the dialogue. Make it more natural and engaging.",
+                output_model,
+            )
+            final_dialogue = output_model.model_validate_json(
+                response.choices[0].message.content
+            )
+            break
+        except ValidationError as e:
+            if attempt == FIREWORKS_JSON_RETRY_ATTEMPTS - 1:  # Last attempt
+                raise ValueError(
+                    f"Failed to improve dialogue after {FIREWORKS_JSON_RETRY_ATTEMPTS} attempts: {e}"
+                ) from e
+            error_message = f"Failed to improve dialogue (attempt {attempt + 1}): {e}"
+            system_prompt_with_dialogue += f"\n\nPlease return a VALID JSON object. This was the earlier error: {error_message}"
+    return final_dialogue
+
+
+def call_llm(system_prompt: str, text: str, dialogue_format: Any) -> Any:
     """Call the LLM with the given prompt and dialogue format."""
-    response = client.chat.completions.create(
+    response = fw_client.chat.completions.create(
         messages=[
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": text},
         ],
-        model=MODEL_ID,
-        max_tokens=16_384,
-        temperature=0.1,
+        model=FIREWORKS_MODEL_ID,
+        max_tokens=FIREWORKS_MAX_TOKENS,
+        temperature=FIREWORKS_TEMPERATURE,
         response_format={
             "type": "json_object",
             "schema": dialogue_format.model_json_schema(),
@@ -74,46 +121,70 @@ def call_llm(system_prompt: str, text: str, dialogue_format):
 
 def parse_url(url: str) -> str:
     """Parse the given URL and return the text content."""
-    full_url = f"{JINA_URL}{url}"
-    response = requests.get(full_url, timeout=60)
+    for attempt in range(JINA_RETRY_ATTEMPTS):
+        try:
+            full_url = f"{JINA_READER_URL}{url}"
+            response = requests.get(full_url, timeout=60)
+            response.raise_for_status()  # Raise an exception for bad status codes
+            break
+        except requests.RequestException as e:
+            if attempt == JINA_RETRY_ATTEMPTS - 1:  # Last attempt
+                raise ValueError(
+                    f"Failed to fetch URL after {JINA_RETRY_ATTEMPTS} attempts: {e}"
+                ) from e
+            time.sleep(JINA_RETRY_DELAY)  # Wait for X second before retrying
     return response.text
 
 
-def generate_podcast_audio(text: str, speaker: str, language: str, use_advanced_audio: bool) -> str:
-
+def generate_podcast_audio(
+    text: str, speaker: str, language: str, use_advanced_audio: bool, random_voice_number: int
+) -> str:
+    """Generate audio for podcast using TTS or advanced audio models."""
     if use_advanced_audio:
-        audio_array = generate_audio(text, history_prompt=f"v2/{language}_speaker_{'1' if speaker == 'Host (Jane)' else '3'}")
-
-        file_path = f"audio_{language}_{speaker}.mp3"
-
-        # save audio to disk
-        write_wav(file_path, SAMPLE_RATE, audio_array)
-
-        return file_path
+        return _use_suno_model(text, speaker, language, random_voice_number)
+    else:
+        return _use_melotts_api(text, speaker, language)
 
 
-    else:
-        if speaker == "Guest":
-            accent = "EN-US" if language == "EN" else language
-            speed = 0.9
-        else:  # host
-            accent = "EN-Default" if language == "EN" else language
-            speed = 1
-        if language != "EN" and speaker != "Guest":
-            speed = 1.1
-
-        # Generate audio
-        for attempt in range(3):
-            try:
-                result = hf_client.predict(
-                    text=text,
-                    language=language,
-                    speaker=accent,
-                    speed=speed,
-                    api_name="/synthesize",
-                )
-                return result
-            except Exception as e:
-                if attempt == 2:  # Last attempt
-                    raise  # Re-raise the last exception if all attempts fail
-                time.sleep(1)  # Wait for 1 second before retrying
+def _use_suno_model(text: str, speaker: str, language: str, random_voice_number: int) -> str:
+    """Generate advanced audio using Bark."""
+    audio_array = generate_audio(
+        text,
+        history_prompt=f"v2/{language}_speaker_{random_voice_number if speaker == 'Host (Jane)' else random_voice_number + 1}",
+    )
+    file_path = f"audio_{language}_{speaker}.mp3"
+    write_wav(file_path, SAMPLE_RATE, audio_array)
+    return file_path
+
+
+def _use_melotts_api(text: str, speaker: str, language: str) -> str:
+    """Generate audio using TTS model."""
+    accent, speed = _get_melo_tts_params(speaker, language)
+
+    for attempt in range(MELO_RETRY_ATTEMPTS):
+        try:
+            return hf_client.predict(
+                text=text,
+                language=language,
+                speaker=accent,
+                speed=speed,
+                api_name=MELO_API_NAME,
+            )
+        except Exception as e:
+            if attempt == MELO_RETRY_ATTEMPTS - 1:  # Last attempt
+                raise  # Re-raise the last exception if all attempts fail
+            time.sleep(MELO_RETRY_DELAY)  # Wait for X second before retrying
+
+
+def _get_melo_tts_params(speaker: str, language: str) -> tuple[str, float]:
+    """Get TTS parameters based on speaker and language."""
+    if speaker == "Guest":
+        accent = "EN-US" if language == "EN" else language
+        speed = 0.9
+    else:  # host
+        accent = "EN-Default" if language == "EN" else language
+        speed = (
+            1.1 if language != "EN" else 1
+        )  # if the language is not English, try speeding up so it'll sound different from the host
+        # for non-English, there is only one voice
+    return accent, speed