Update conver.py

conver.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, Tuple, Dict
+from typing import List, Tuple, Dict, Optional
 import os
 import re
 import httpx
@@ -7,19 +7,16 @@ import json
 from openai import OpenAI
 import edge_tts
 import tempfile
-import wave
 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
@@ -43,41 +40,45 @@ class URLToAudioConverter:
             raise ValueError("Input text cannot be empty")
 
         try:
+            # Prompt mejorado para obtener JSON consistente
+            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": self._build_prompt(text)}],
+                messages=[{"role": "user", "content": prompt}],
                 model=self.config.model_name,
+                response_format={"type": "json_object"}  # Fuerza formato JSON
             )
-
-            pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
-            json_match = re.search(pattern, chat_completion.choices[0].message.content)
-
-            if not json_match:
-                raise ValueError("No valid JSON found in response")
-
-            return json.loads(json_match.group())
+            
+            # Extracción robusta de JSON
+            response_content = chat_completion.choices[0].message.content
+            json_str = response_content.strip()
+            
+            # Limpieza de texto alrededor del JSON
+            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:
-            raise RuntimeError(f"Failed to extract conversation: {e}")
-
-    def _build_prompt(self, text: str) -> str:
-        template = """
-        {
-            "conversation": [
-                {"speaker": "", "text": ""},
-                {"speaker": "", "text": ""}
-            ]
-        }
-        """
-        return (
-            f"{text}\nConvert the provided text into a short informative and crisp "
-            f"podcast conversation between two experts. The tone should be "
-            f"professional and engaging. Please adhere to the following "
-            f"format and return the conversation in JSON:\n{template}"
-        )
+            # Debug: Imprime la respuesta del modelo para diagnóstico
+            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}.wav"
@@ -122,33 +123,32 @@ class URLToAudioConverter:
             raise ValueError("No input files provided")
 
         try:
-            audio_segments = []
-
+            combined = AudioSegment.empty()
             for filename in filenames:
-                audio_segment = AudioSegment.from_mp3(filename)
-                audio_segments.append(audio_segment)
-
-            combined = sum(audio_segments)
+                audio_segment = AudioSegment.from_wav(filename)
+                combined += audio_segment
 
             combined.export(output_file, format="wav")
 
+            # Limpieza de archivos temporales
             for filename in filenames:
                 os.remove(filename)
-
+            os.rmdir(os.path.dirname(filenames[0]))
+                
         except Exception as e:
             raise RuntimeError(f"Failed to combine audio files: {e}")
 
-    async def url_to_audio(self, url: str, voice_1: str, voice_2: str) -> str:
+    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])
+            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"]
-    )
+            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
@@ -156,4 +156,17 @@ class URLToAudioConverter:
 
         final_output = os.path.join(folder_name, "combined_output.wav")
         self.combine_audio_files(audio_files, final_output)
-        return final_output,conversation_text
+        return final_output, conversation_text
+
+    async def text_to_audio(self, text: str, voice_1: str, voice_2: str) -> Tuple[str, str]:
+        """Nuevo método para procesar texto directo"""
+        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
+        )
+        final_output = os.path.join(folder_name, "combined_output.wav")
+        self.combine_audio_files(audio_files, final_output)
+        return final_output, conversation_text