Script Generation

def generate_script(
    video_subject: str,
    paragraph_number: int,
    ai_model: str,
    voice: str,
    customPrompt: str,
) -> Optional[str]:
    """
    Generate a script for a video, depending on the subject of the video, 
    the number of paragraphs, and the AI model.
    
    Args:
        video_subject (str): The subject of the video.
        paragraph_number (int): The number of paragraphs to generate.
        ai_model (str): The AI model to use for generation.
        voice (str): The voice/language for the script.
        customPrompt (str): Optional custom prompt override.
    
    Returns:
        str: The generated script for the video.
    """

prompt = f"""
Generate a script for a video, depending on the subject of the video.

The script is to be returned as a string with the specified number of paragraphs.

YOU MUST NOT INCLUDE ANY TYPE OF MARKDOWN OR FORMATTING IN THE SCRIPT, NEVER USE A TITLE.
YOU MUST WRITE THE SCRIPT IN THE LANGUAGE SPECIFIED IN [LANGUAGE].
ONLY RETURN THE RAW CONTENT OF THE SCRIPT.

Subject: {video_subject}
Number of paragraphs: {paragraph_number}
Language: {voice}
"""

OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=llama3.1:8b
OLLAMA_TIMEOUT=180

from ollama import Client

def _ollama_client() -> Client:
    return Client(host=OLLAMA_BASE_URL, timeout=OLLAMA_TIMEOUT)

def list_ollama_models() -> Tuple[List[str], str]:
    """
    Returns available Ollama model names and configured default model.
    
    Returns:
        Tuple[List[str], str]: (available model names, default model)
    """

def generate_response(prompt: str, ai_model: str) -> str:
    """
    Generate a response from the AI model.
    
    Args:
        prompt (str): The prompt to send to the model.
        ai_model (str): The AI model to use.
    
    Returns:
        str: The response from the AI model.
    """

try:
    response = client.chat(
        model=model_name,
        messages=[{"role": "user", "content": prompt}],
        stream=False,
    )
except ResponseError as err:
    if err.status_code == 404:
        response = client.generate(
            model=model_name, prompt=prompt, stream=False
        )

def generate_metadata(
    video_subject: str, script: str, ai_model: str
) -> Tuple[str, str, List[str]]:
    """
    Generate metadata for a YouTube video, including the title, 
    description, and keywords.
    
    Args:
        video_subject (str): The subject of the video.
        script (str): The script of the video.
        ai_model (str): The AI model to use.
    
    Returns:
        Tuple[str, str, List[str]]: The title, description, and keywords.
    """

from Backend.gpt import generate_script, generate_metadata

# Generate a script
script = generate_script(
    video_subject="The History of Space Exploration",
    paragraph_number=3,
    ai_model="llama3.1:8b",
    voice="en_us_001",
    customPrompt=""  # Use default prompt
)

if script:
    print(f"Generated script:\n{script}")
    
    # Generate metadata
    title, description, keywords = generate_metadata(
        video_subject="The History of Space Exploration",
        script=script,
        ai_model="llama3.1:8b"
    )
    
    print(f"\nTitle: {title}")
    print(f"Description: {description}")
    print(f"Keywords: {', '.join(keywords)}")

# Remove asterisks, hashes
response = response.replace("*", "")
response = response.replace("#", "")

# Remove markdown syntax
response = re.sub(r"\[.*\]", "", response)
response = re.sub(r"\(.*\)", "", response)

def get_search_terms(
    video_subject: str, amount: int, script: str, ai_model: str
) -> List[str]:
    """
    Generate a JSON-Array of search terms for stock videos.
    
    Args:
        video_subject (str): The subject of the video.
        amount (int): The amount of search terms to generate.
        script (str): The script of the video.
        ai_model (str): The AI model to use.
    
    Returns:
        List[str]: The search terms for the video subject.
    """