Update conver.py

conver.py

@@ -23,32 +23,99 @@ class URLToAudioConverter:
         self.config = config
         self.llm_client = OpenAI(api_key=llm_api_key, base_url="https://api.together.xyz/v1")
         self.llm_out = None
-        self._start_cleaner()  # 👈 Inicia el limpiador automático
+        self._start_cleaner()  # Inicia limpieza automática
 
     def _start_cleaner(self, max_age_hours: int = 24):
-        """Hilo para eliminar archivos antiguos automáticamente"""
+        """Elimina archivos antiguos cada hora"""
         def cleaner():
             while True:
                 now = time.time()
                 for root, _, files in os.walk("."):
                     for file in files:
-                        if file.endswith((".mp3", ".wav")):  # Formatos a limpiar
+                        if file.endswith((".mp3", ".wav")):
                             filepath = os.path.join(root, file)
                             try:
-                                file_age = now - os.path.getmtime(filepath)
-                                if file_age > max_age_hours * 3600:
+                                if now - os.path.getmtime(filepath) > max_age_hours * 3600:
                                     os.remove(filepath)
                             except:
-                                continue
-                time.sleep(3600)  # Revisa cada hora
-
+                                pass
+                time.sleep(3600)
         Thread(target=cleaner, daemon=True).start()
 
-    # ... [TODOS TUS MÉTODOS ORIGINALES SE MANTIENEN IGUAL A PARTIR DE AQUÍ] ...
-    # fetch_text, extract_conversation, text_to_speech, etc.
-    # ...
+    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 this into a podcast dialogue between Host1 and Host2. Return ONLY:\nHost1: [text]\nHost2: [text]\n..."
+            response = self.llm_client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model=self.config.model_name
+            )
+            raw_text = response.choices[0].message.content
+            dialogue = {"conversation": []}
+            for line in raw_text.split('\n'):
+                if ':' in line:
+                    speaker, _, content = line.partition(':')
+                    if speaker.strip() in ("Host1", "Host2"):
+                        dialogue["conversation"].append({
+                            "speaker": speaker.strip(),
+                            "text": content.strip()
+                        })
+            return dialogue
+        except Exception as e:
+            raise RuntimeError(f"Failed to parse dialogue: {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"segment_{i}.mp3"
+                voice = voice_1 if turn["speaker"] == "Host1" else voice_2
+                tmp_path = await self._generate_audio(turn["text"], voice)
+                os.rename(tmp_path, filename)
+                filenames.append(str(filename))
+            return filenames, str(output_dir)
+        except Exception as e:
+            raise RuntimeError(f"Text-to-speech failed: {e}")
+
+    async def _generate_audio(self, text: str, voice: str) -> str:
+        if not text.strip():
+            raise ValueError("Text cannot be empty")
+        communicate = edge_tts.Communicate(
+            text,
+            voice.split(" - ")[0],
+            rate="+0%",
+            pitch="+0Hz"
+        )
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+            await communicate.save(tmp_file.name)
+            return tmp_file.name
+
+    def _create_output_directory(self) -> str:
+        folder_name = base64.urlsafe_b64encode(os.urandom(8)).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 audio files provided")
+        combined = AudioSegment.empty()
+        for filename in filenames:
+            combined += AudioSegment.from_file(filename, format="mp3")
+        return combined
 
-    # Método add_background_music_and_tags con paréntesis corregido (sin otros cambios)
     def add_background_music_and_tags(
         self,
         speech_audio: AudioSegment,
@@ -57,7 +124,7 @@ class URLToAudioConverter:
     ) -> AudioSegment:
         music = AudioSegment.from_file(music_path).fade_out(2000) - 25
         if len(music) < len(speech_audio):
-            music = music * ((len(speech_audio) // len(music)) + 1  # 👈 Paréntesis corregido
+            music = music * ((len(speech_audio) // len(music)) + 1
         music = music[:len(speech_audio)]
         mixed = speech_audio.overlay(music)
         
@@ -77,4 +144,42 @@ class URLToAudioConverter:
         
         return final_audio
 
-    # ... [EL RESTO DE TUS MÉTODOS (url_to_audio, text_to_audio, etc.) SIN CAMBIOS] ...
+    async def url_to_audio(self, url: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
+        text = self.fetch_text(url)
+        if len(words := text.split()) > self.config.max_words:
+            text = " ".join(words[:self.config.max_words])
+        conversation = self.extract_conversation(text)
+        return await self._process_to_audio(conversation, voice_1, voice_2)
+
+    async def text_to_audio(self, text: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
+        conversation = self.extract_conversation(text)
+        return await self._process_to_audio(conversation, voice_1, voice_2)
+
+    async def raw_text_to_audio(self, text: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
+        conversation = {"conversation": [{"speaker": "Host1", "text": text}]}
+        return await self._process_to_audio(conversation, voice_1, voice_2)
+
+    async def _process_to_audio(
+        self,
+        conversation: Dict,
+        voice_1: str,
+        voice_2: str
+    ) -> Tuple[str, str]:
+        audio_files, folder_name = await self.text_to_speech(conversation, voice_1, voice_2)
+        combined = self.combine_audio_files(audio_files)
+        final_audio = self.add_background_music_and_tags(
+            combined,
+            "musica.mp3",
+            ["tag.mp3", "tag2.mp3"]
+        )
+        output_path = os.path.join(folder_name, "podcast_final.mp3")
+        final_audio.export(output_path, format="mp3")
+        
+        for f in audio_files:
+            os.remove(f)
+            
+        text_output = "\n".join(
+            f"{turn['speaker']}: {turn['text']}" 
+            for turn in conversation["conversation"]
+        )
+        return output_path, text_output