Demo Automatic Language Recognition and Translation

from dotenv import load_dotenv
import os
from pathlib import Path
import asyncio
import re

# OpenAI Python client
from openai import OpenAI

# Optional display in notebooks
from IPython.display import Image, display

# Agent & Runner (kept as in the original content)
from agents import Agent, Runner

# Load environment variables
load_dotenv()

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

async def transcribe_audio(file_path: str) -> str:
    """
    Transcribe a WAV file using the Whisper model and return the transcription text.
    """
    # Ensure the file exists
    path = Path(file_path)
    if not path.exists():
        raise FileNotFoundError(f"Audio file not found: {file_path}")

    with open(file_path, "rb") as audio_file:
        transcript = client.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file
        )

    # The client returns an object with a text attribute for the transcript
    return getattr(transcript, "text", transcript.get("text") if isinstance(transcript, dict) else None)

async def analyze_language_and_emotion(text: str) -> dict:
    """
    Ask a chat model to detect the language and a one-word emotional tone for the given text.
    Returns: {"language": "<language>", "emotion": "<emotion>"}
    """
    system_msg = (
        "You're an AI that analyzes messages. Detect the language (e.g., English, French) "
        "and describe the emotional tone in one word (e.g., joyful, sad, angry, professional, excited, persuasive). "
        "Respond in the format:\nLanguage: <language>\nEmotion: <emotion>"
    )

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": f"Here is the message:\n{text}"}
        ],
        temperature=0.3
    )

    content = response.choices[0].message.content.strip()

    # Tolerant regex to capture "Language: ..." and "Emotion: ..." (allow multi-word and punctuation)
    language_match = re.search(r"(?i)^\s*Language[:\-\s]*([^\r\n]+)", content, re.MULTILINE)
    emotion_match = re.search(r"(?i)^\s*Emotion[:\-\s]*([^\r\n]+)", content, re.MULTILINE)

    return {
        "language": language_match.group(1).strip() if language_match else "Unknown",
        "emotion": emotion_match.group(1).strip() if emotion_match else "Unknown"
    }

translator_agent = Agent(
    name="Translator",
    instructions="Translate the input text into English. Only return the translated result."
)

async def translate_text(text: str) -> str:
    """
    Use the Agent Runner to translate text into English.
    Returns the final translated string returned by the agent.
    """
    result = await Runner.run(translator_agent, input=text)
    # Handle common return shapes: string, object with attribute, or dict
    if isinstance(result, str):
        return result
    return getattr(result, "final_output", result.get("final_output") if isinstance(result, dict) else None)

async def generate_title_and_summary(text: str) -> str:
    """
    Generate a concise summary and a suggested title for the given text.
    Returns a string containing both title and summary.
    """
    system_msg = "You are a helpful AI assistant. Summarize the user's message and suggest a title for it."

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": f"Here's the text:\n\n{text}"}
        ],
        temperature=0.5
    )

    return response.choices[0].message.content.strip()

async def process_audio_translation(file_path: str):
    """
    Full pipeline for an audio file:
      1. Transcribe audio
      2. Analyze language and emotion
      3. Translate into English
      4. Generate title and summary
    Prints each result step to the console.
    """
    # 1) Transcribe
    transcript = await transcribe_audio(file_path)
    print(f"Transcript:\n{transcript}\n")

    # 2) Language & emotion analysis
    analysis = await analyze_language_and_emotion(transcript)
    print(f"Detected language: {analysis['language']}")
    print(f"Detected emotion: {analysis['emotion']}\n")

    # 3) Translate to English
    translation = await translate_text(transcript)
    print(f"Translation:\n{translation}\n")

    # 4) Title & summary
    extras = await generate_title_and_summary(translation)
    print(f"Title and Summary:\n{extras}\n")

# Replace with the path to your WAV file
audio_path = "/Users/gavinridgeway/Documents/Anaconda/AiAgent/final_fixed.wav"

await process_audio_translation(audio_path)

if __name__ == "__main__":
    audio_path = "/path/to/your/file.wav"
    asyncio.run(process_audio_translation(audio_path))