Spaces:
Running
Running
| 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 | |
| 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 | |