conver.py

from dataclasses import dataclass
from typing import List, Tuple, Dict
import os
import re
import httpx
import json
from openai import OpenAI
import edge_tts
import tempfile
from pydub import AudioSegment
import base64
from pathlib import Path
import hashlib
import asyncio

@dataclass
class ConversationConfig:
    max_words: int = 3000
    prefix_url: str = "https://r.jina.ai/"
    model_name: str = "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"

class URLToAudioConverter:
    def __init__(self, config: ConversationConfig, llm_api_key: str):
        self.config = config
        self.llm_client = OpenAI(api_key=llm_api_key, base_url="https://api.together.xyz/v1")
        self.llm_out = None

    def fetch_text(self, url: str) -> str:
        if not url:
            raise ValueError("URL cannot be empty")
        response = httpx.get(f"{self.config.prefix_url}{url}", timeout=60.0)
        response.raise_for_status()
        return response.text

    def extract_conversation(self, text: str) -> Dict:
        prompt = (
            f"{text}\nConvert the provided text into a short informative podcast conversation "
            f"between two experts. Return ONLY a JSON object with the following structure:\n"
            '{"conversation": [{"speaker": "Speaker1", "text": "..."}, {"speaker": "Speaker2", "text": "..."}]}'
        )
        chat_completion = self.llm_client.chat.completions.create(
            messages=[{"role": "user", "content": prompt}],
            model=self.config.model_name,
            response_format={"type": "json_object"}
        )
        response_content = chat_completion.choices[0].message.content
        json_str = response_content.strip()
        if not json_str.startswith("{"):
            json_str = json_str[json_str.find("{"):]
        if not json_str.endswith("}"):
            json_str = json_str[: json_str.rfind("}") + 1]
        return json.loads(json_str)

    async def text_to_speech(self, conversation_json: Dict, voice_1: str, voice_2: str) -> Tuple[List[str], str]:
        output_dir = Path(self._create_output_directory())
        filenames = []
        for i, turn in enumerate(conversation_json["conversation"]):
            voice = voice_1 if i % 2 == 0 else voice_2
            tmp_path, error = await self._generate_audio(turn["text"], voice)
            if error:
                raise RuntimeError(f"Text-to-speech failed: {error}")
            filename = output_dir / f"output_{i}.mp3"
            os.rename(tmp_path, filename)
            filenames.append(str(filename))
        return filenames, str(output_dir)

    async def _generate_audio(self, text: str, voice: str, rate: int = 0, pitch: int = 0) -> Tuple[str, str]:
        voice_short_name = voice.split(" - ")[0]
        rate_str = f"{rate:+d}%"
        pitch_str = f"{pitch:+d}Hz"
        communicate = edge_tts.Communicate(text, voice_short_name, rate=rate_str, pitch=pitch_str)
        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
            tmp_path = tmp_file.name
            await communicate.save(tmp_path)
        return tmp_path, None

    def _create_output_directory(self) -> str:
        random_bytes = os.urandom(8)
        folder_name = base64.urlsafe_b64encode(random_bytes).decode("utf-8")
        os.makedirs(folder_name, exist_ok=True)
        return folder_name

    def combine_audio_files(self, filenames: List[str], output_file: str) -> None:
        combined = AudioSegment.empty()
        for filename in filenames:
            combined += AudioSegment.from_file(filename, format="mp3")
        combined.export(output_file, format="mp3")
        dir_path = os.path.dirname(filenames[0])
        for file in os.listdir(dir_path):
            os.remove(os.path.join(dir_path, file))
        os.rmdir(dir_path)

    async def url_to_audio(self, url: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
        text = self.fetch_text(url)
        words = text.split()
        if len(words) > self.config.max_words:
            text = " ".join(words[: self.config.max_words])
        conversation_json = self.extract_conversation(text)
        conversation_text = "\n".join(f"{t['speaker']}: {t['text']}" for t in conversation_json["conversation"])
        self.llm_out = conversation_json
        audio_files, folder_name = await self.text_to_speech(conversation_json, voice_1, voice_2)
        final_output = os.path.join(folder_name, "combined_output.mp3")
        self.combine_audio_files(audio_files, final_output)
        return final_output, conversation_text

    async def text_to_audio(self, text: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
        conversation_json = self.extract_conversation(text)
        conversation_text = "\n".join(f"{t['speaker']}: {t['text']}" for t in conversation_json["conversation"])
        audio_files, folder_name = await self.text_to_speech(conversation_json, voice_1, voice_2)
        final_output = os.path.join(folder_name, "combined_output.mp3")
        self.combine_audio_files(audio_files, final_output)
        return final_output, conversation_text

    async def raw_text_to_audio(self, text: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
        try:
            print("\n=== DEBUG INICIO (raw_text_to_audio) ===")
            print(f"Texto recibido: {text[:200]}...")  # Verifica el input
            
            # Usa una ruta absoluta en /tmp (compatible con Spaces)
            output_dir = "/tmp/podcast_outputs"
            os.makedirs(output_dir, exist_ok=True)
            hash_name = hashlib.md5(text.encode()).hexdigest()[:8]
            output_file = os.path.join(output_dir, f"podcast_{hash_name}.mp3")
            print(f"Ruta de salida: {output_file}")

            # Verifica voces disponibles (DEBUG)
            voices = await edge_tts.list_voices()
            voice_names = [v['Name'] for v in voices]
            print(f"Voces disponibles (primeras 5): {voice_names[:5]}...")

            # Extrae el nombre corto de la voz (ej: "en-US-AvaMultilingualNeural")
            voice_short = voice_1.split(" - ")[0] if " - " in voice_1 else voice_1
            print(f"Voz a usar: {voice_short}")

            # Genera el audio
            communicate = edge_tts.Communicate(text, voice_short)
            print("Generando audio...")
            await communicate.save(output_file)
            print("Audio generado.")

            # Verifica que el archivo existe y no está vacío
            if not os.path.exists(output_file):
                print("ERROR: Archivo no creado.")
                return "Error: Archivo no generado", None
            elif os.path.getsize(output_file) == 0:
                print("ERROR: Archivo vacío.")
                return "Error: Archivo de audio vacío", None

            print(f"=== DEBUG FIN (Archivo válido: {output_file}) ===")
            return text, output_file

        except Exception as e:
            print(f"ERROR CRÍTICO: {str(e)}")
            return f"Error: {str(e)}", None