conver.py

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

@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")
        full_url = f"{self.config.prefix_url}{url}"
        try:
            response = httpx.get(full_url, timeout=60.0)
            response.raise_for_status()
            return response.text
        except httpx.HTTPError as e:
            raise RuntimeError(f"Failed to fetch URL: {e}")

    def extract_conversation(self, text: str) -> Dict:
        if not text:
            raise ValueError("Input text cannot be empty")
        try:
            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('{'):
                start = json_str.find('{')
                if start != -1:
                    json_str = json_str[start:]
            if not json_str.endswith('}'):
                end = json_str.rfind('}')
                if end != -1:
                    json_str = json_str[:end+1]
            return json.loads(json_str)
        except Exception as e:
            print(f"Error en extract_conversation: {str(e)}")
            print(f"Respuesta del modelo: {response_content}")
            raise RuntimeError(f"Failed to extract conversation: {str(e)}")

    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 = []
        try:
            for i, turn in enumerate(conversation_json["conversation"]):
                filename = output_dir / f"output_{i}.mp3"
                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}")
                os.rename(tmp_path, filename)
                filenames.append(str(filename))
            return filenames, str(output_dir)
        except Exception as e:
            raise RuntimeError(f"Failed to convert text to speech: {e}")

    async def _generate_audio(self, text: str, voice: str, rate: int = 0, pitch: int = 0) -> Tuple[str, str]:
        if not text.strip():
            return None, "Text cannot be empty"
        if not voice:
            return None, "Voice cannot be empty"
        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]) -> AudioSegment:
        if not filenames:
            raise ValueError("No input files provided")
        try:
            combined = AudioSegment.empty()
            for filename in filenames:
                audio_segment = AudioSegment.from_file(filename, format="mp3")
                combined += audio_segment
            return combined
        except Exception as e:
            raise RuntimeError(f"Failed to combine audio files: {e}")

    def add_background_music_and_tags(
        self, speech_audio: AudioSegment, music_file: str, tags_files: List[str]
    ) -> AudioSegment:
        music = AudioSegment.from_file(music_file)
        if len(music) < len(speech_audio):
            loops = (len(speech_audio) // len(music)) + 1
            music = music * loops
        music = music[:len(speech_audio)] - 20  # bajar volumen música
        mixed = speech_audio.overlay(music)
        for i, tag_path in enumerate(tags_files):
            tag_audio = AudioSegment.from_file(tag_path) - 5
            if i == 0:
                mixed = tag_audio + mixed
            else:
                mixed = mixed + tag_audio
        return mixed

    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"{turn['speaker']}: {turn['text']}" for turn in conversation_json["conversation"]
        )
        self.llm_out = conversation_json
        audio_files, folder_name = await self.text_to_speech(conversation_json, voice_1, voice_2)
        combined_audio = self.combine_audio_files(audio_files)
        music_path = "assets/musica.mp3"
        tags_paths = ["assets/tag.mp3", "assets/tag2.mp3"]
        final_audio = self.add_background_music_and_tags(combined_audio, music_path, tags_paths)
        final_output = os.path.join(folder_name, "combined_output_with_music.mp3")
        final_audio.export(final_output, format="mp3")
        for f in audio_files:
            os.remove(f)
        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"{turn['speaker']}: {turn['text']}" for turn in conversation_json["conversation"]
        )
        audio_files, folder_name = await self.text_to_speech(conversation_json, voice_1, voice_2)
        combined_audio = self.combine_audio_files(audio_files)
        music_path = "assets/musica.mp3"
        tags_paths = ["assets/tag.mp3", "assets/tag2.mp3"]
        final_audio = self.add_background_music_and_tags(combined_audio, music_path, tags_paths)
        final_output = os.path.join(folder_name, "combined_output_with_music.mp3")
        final_audio.export(final_output, format="mp3")
        for f in audio_files:
            os.remove(f)
        return final_output, conversation_text

    async def raw_text_to_audio(self, text: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
        conversation = {
            "conversation": [
                {"speaker": "Host", "text": text},
                {"speaker": "Co-host", "text": "(Continuación del tema)"}
            ]
        }
        audio_files, folder_name = await self.text_to_speech(conversation, voice_1, voice_2)
        combined_audio = self.combine_audio_files(audio_files)
        music_path = "assets/musica.mp3"
        tags_paths = ["assets/tag.mp3", "assets/tag2.mp3"]
        final_audio = self.add_background_music_and_tags(combined_audio, music_path, tags_paths)
        output_file = os.path.join(folder_name, "raw_podcast_with_music.mp3")
        final_audio.export(output_file, format="mp3")
        for f in audio_files:
            os.remove(f)
        return text, output_file