Update app.py

app.py

@@ -4,31 +4,31 @@ import whisper
 import tempfile
 import gradio as gr
 from pydub import AudioSegment
-import fitz  # PyMuPDF para manejar PDFs
-import docx  # Para manejar archivos .docx
-import pandas as pd  # Para manejar archivos .xlsx y .csv
-#from google.colab import userdata  # Importa userdata de google.colab
+import fitz  # PyMuPDF for handling PDFs
+import docx  # For handling .docx files
+import pandas as pd  # For handling .xlsx and .csv files
+#from google.colab import userdata  # Import userdata from google.colab
 import requests
 from bs4 import BeautifulSoup
 from moviepy.editor import VideoFileClip
 import yt_dlp
 import logging
 
-# Configurar logging
+# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configura tu clave API de OpenAI usando Google Colab userdata
+# Configure your OpenAI API key using Google Colab userdata
 #openai.api_key = userdata.get('OPENAI_API_KEY')
 
-# Cargar las variables de entorno desde el entorno de Hugging Face
+# Load environment variables from the Hugging Face environment
 openai.api_key = os.getenv("OPENAI_API_KEY")
 
-# Cargar el modelo Whisper de mayor calidad una vez
+# Load the highest quality Whisper model once
 model = whisper.load_model("large")
 
 def download_social_media_video(url):
-    """Descarga un video de redes sociales."""
+    """Download a video from social media."""
     ydl_opts = {
         'format': 'bestaudio/best',
         'postprocessors': [{
@@ -42,256 +42,256 @@ def download_social_media_video(url):
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
             info_dict = ydl.extract_info(url, download=True)
             audio_file = f"{info_dict['id']}.mp3"
-        logger.info(f"Video descargado exitosamente: {audio_file}")
+        logger.info(f"Video downloaded successfully: {audio_file}")
         return audio_file
     except Exception as e:
-        logger.error(f"Error al descargar el video: {str(e)}")
+        logger.error(f"Error downloading the video: {str(e)}")
         raise
 
 def convert_video_to_audio(video_file):
-    """Convierte un archivo de video a audio."""
+    """Convert a video file to audio."""
     try:
         video = VideoFileClip(video_file)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_file:
             video.audio.write_audiofile(temp_file.name)
-            logger.info(f"Video convertido a audio: {temp_file.name}")
+            logger.info(f"Video converted to audio: {temp_file.name}")
             return temp_file.name
     except Exception as e:
-        logger.error(f"Error al convertir el video a audio: {str(e)}")
+        logger.error(f"Error converting video to audio: {str(e)}")
         raise
 
 def preprocess_audio(audio_file):
-    """Preprocesa el archivo de audio para mejorar la calidad."""
+    """Preprocess the audio file to improve quality."""
     try:
         audio = AudioSegment.from_file(audio_file)
         audio = audio.apply_gain(-audio.dBFS + (-20))
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_file:
             audio.export(temp_file.name, format="mp3")
-            logger.info(f"Audio preprocesado: {temp_file.name}")
+            logger.info(f"Audio preprocessed: {temp_file.name}")
             return temp_file.name
     except Exception as e:
-        logger.error(f"Error al preprocesar el archivo de audio: {str(e)}")
+        logger.error(f"Error preprocessing the audio file: {str(e)}")
         raise
 
-def transcribir_audio(file):
-    """Transcribe un archivo de audio o video."""
+def transcribe_audio(file):
+    """Transcribe an audio or video file."""
     try:
         if isinstance(file, str) and file.startswith('http'):
-            logger.info(f"Descargando video de red social: {file}")
-            archivo_path = download_social_media_video(file)
+            logger.info(f"Downloading social media video: {file}")
+            file_path = download_social_media_video(file)
         elif isinstance(file, str) and file.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
-            logger.info(f"Convirtiendo video local a audio: {file}")
-            archivo_path = convert_video_to_audio(file)
+            logger.info(f"Converting local video to audio: {file}")
+            file_path = convert_video_to_audio(file)
         else:
-            logger.info(f"Preprocesando archivo de audio: {file}")
-            archivo_path = preprocess_audio(file)
-
-        logger.info(f"Transcribiendo audio: {archivo_path}")
-        resultado = model.transcribe(archivo_path)
-        transcripcion = resultado.get("text", "Error en la transcripción")
-        logger.info(f"Transcripción completada: {transcripcion[:50]}...")
-        return transcripcion
+            logger.info(f"Preprocessing audio file: {file}")
+            file_path = preprocess_audio(file)
+
+        logger.info(f"Transcribing audio: {file_path}")
+        result = model.transcribe(file_path)
+        transcription = result.get("text", "Error in transcription")
+        logger.info(f"Transcription completed: {transcription[:50]}...")
+        return transcription
     except Exception as e:
-        logger.error(f"Error al procesar el archivo: {str(e)}")
-        return f"Error al procesar el archivo: {str(e)}"
+        logger.error(f"Error processing the file: {str(e)}")
+        return f"Error processing the file: {str(e)}"
 
-def leer_documento(documento_path):
-    """Lee el contenido de un documento PDF, DOCX, XLSX o CSV."""
+def read_document(document_path):
+    """Read the content of a PDF, DOCX, XLSX or CSV document."""
     try:
-        if documento_path.endswith(".pdf"):
-            doc = fitz.open(documento_path)
-            return "\n".join([pagina.get_text() for pagina in doc])
-        elif documento_path.endswith(".docx"):
-            doc = docx.Document(documento_path)
-            return "\n".join([parrafo.text for parrafo in doc.paragraphs])
-        elif documento_path.endswith(".xlsx"):
-            return pd.read_excel(documento_path).to_string()
-        elif documento_path.endswith(".csv"):
-            return pd.read_csv(documento_path).to_string()
+        if document_path.endswith(".pdf"):
+            doc = fitz.open(document_path)
+            return "\n".join([page.get_text() for page in doc])
+        elif document_path.endswith(".docx"):
+            doc = docx.Document(document_path)
+            return "\n".join([paragraph.text for paragraph in doc.paragraphs])
+        elif document_path.endswith(".xlsx"):
+            return pd.read_excel(document_path).to_string()
+        elif document_path.endswith(".csv"):
+            return pd.read_csv(document_path).to_string()
         else:
-            return "Tipo de archivo no soportado. Por favor suba un documento PDF, DOCX, XLSX o CSV."
+            return "Unsupported file type. Please upload a PDF, DOCX, XLSX or CSV document."
     except Exception as e:
-        return f"Error al leer el documento: {str(e)}"
+        return f"Error reading the document: {str(e)}"
 
-def leer_url(url):
-    """Lee el contenido de una URL."""
+def read_url(url):
+    """Read the content of a URL."""
     try:
         response = requests.get(url)
         response.raise_for_status()
         soup = BeautifulSoup(response.content, 'html.parser')
         return soup.get_text()
     except Exception as e:
-        return f"Error al leer la URL: {str(e)}"
+        return f"Error reading the URL: {str(e)}"
 
-def procesar_contenido_social(url):
-    """Procesa el contenido de una URL de red social, manejando tanto texto como video."""
+def process_social_content(url):
+    """Process the content of a social media URL, handling both text and video."""
     try:
-        # Primero, intentamos leer el contenido como texto
-        contenido_texto = leer_url(url)
+        # First, try to read the content as text
+        text_content = read_url(url)
 
-        # Luego, intentamos procesar como video
+        # Then, try to process as video
         try:
-            contenido_video = transcribir_audio(url)
+            video_content = transcribe_audio(url)
         except Exception:
-            contenido_video = None
+            video_content = None
 
         return {
-            "texto": contenido_texto,
-            "video": contenido_video
+            "text": text_content,
+            "video": video_content
         }
     except Exception as e:
-        logger.error(f"Error al procesar contenido social: {str(e)}")
+        logger.error(f"Error processing social content: {str(e)}")
         return None
 
-def generar_noticia(instrucciones, hechos, tamaño, tono, *args):
-    """Genera una noticia a partir de instrucciones, hechos, URLs, documentos, transcripciones y contenido de redes sociales."""
-    base_de_conocimiento = {
-        "instrucciones": instrucciones,
-        "hechos": hechos,
-        "contenido_documentos": [],
+def generate_news(instructions, facts, size, tone, *args):
+    """Generate a news article from instructions, facts, URLs, documents, transcriptions, and social media content."""
+    knowledge_base = {
+        "instructions": instructions,
+        "facts": facts,
+        "document_content": [],
         "audio_data": [],
-        "contenido_urls": [],
-        "contenido_social": []
+        "url_content": [],
+        "social_content": []
     }
-    num_audios = 5 * 3  # 5 audios/videos * 3 campos (archivo, nombre, cargo)
-    num_social_urls = 3 * 3  # 3 URLs de redes sociales * 3 campos (URL, nombre, contexto)
-    num_urls = 5  # 5 URLs generales
+    num_audios = 5 * 3  # 5 audios/videos * 3 fields (file, name, position)
+    num_social_urls = 3 * 3  # 3 social media URLs * 3 fields (URL, name, context)
+    num_urls = 5  # 5 general URLs
     audios = args[:num_audios]
     social_urls = args[num_audios:num_audios+num_social_urls]
     urls = args[num_audios+num_social_urls:num_audios+num_social_urls+num_urls]
-    documentos = args[num_audios+num_social_urls+num_urls:]
+    documents = args[num_audios+num_social_urls+num_urls:]
 
     for url in urls:
         if url:
-            base_de_conocimiento["contenido_urls"].append(leer_url(url))
+            knowledge_base["url_content"].append(read_url(url))
 
-    for documento in documentos:
-        if documento is not None:
-            base_de_conocimiento["contenido_documentos"].append(leer_documento(documento.name))
+    for document in documents:
+        if document is not None:
+            knowledge_base["document_content"].append(read_document(document.name))
 
     for i in range(0, len(audios), 3):
-        audio_file, nombre, cargo = audios[i:i+3]
+        audio_file, name, position = audios[i:i+3]
         if audio_file is not None:
-            base_de_conocimiento["audio_data"].append({"audio": audio_file, "nombre": nombre, "cargo": cargo})
+            knowledge_base["audio_data"].append({"audio": audio_file, "name": name, "position": position})
 
     for i in range(0, len(social_urls), 3):
-        social_url, social_nombre, social_contexto = social_urls[i:i+3]
+        social_url, social_name, social_context = social_urls[i:i+3]
         if social_url:
-            contenido_social = procesar_contenido_social(social_url)
-            if contenido_social:
-                base_de_conocimiento["contenido_social"].append({
+            social_content = process_social_content(social_url)
+            if social_content:
+                knowledge_base["social_content"].append({
                     "url": social_url,
-                    "nombre": social_nombre,
-                    "contexto": social_contexto,
-                    "texto": contenido_social["texto"],
-                    "video": contenido_social["video"]
+                    "name": social_name,
+                    "context": social_context,
+                    "text": social_content["text"],
+                    "video": social_content["video"]
                 })
-                logger.info(f"Contenido de red social procesado: {social_url}")
+                logger.info(f"Social media content processed: {social_url}")
 
-    transcripciones_texto, transcripciones_brutas = "", ""
+    transcriptions_text, raw_transcriptions = "", ""
 
-    for idx, data in enumerate(base_de_conocimiento["audio_data"]):
+    for idx, data in enumerate(knowledge_base["audio_data"]):
         if data["audio"] is not None:
-            transcripcion = transcribir_audio(data["audio"])
-            transcripcion_texto = f'"{transcripcion}" - {data["nombre"]}, {data["cargo"]}'
-            transcripcion_bruta = f'[Audio/Video {idx + 1}]: "{transcripcion}" - {data["nombre"]}, {data["cargo"]}'
-            transcripciones_texto += transcripcion_texto + "\n"
-            transcripciones_brutas += transcripcion_bruta + "\n\n"
-
-    for data in base_de_conocimiento["contenido_social"]:
-        if data["texto"]:
-            transcripcion_texto = f'[Texto de red social]: "{data["texto"][:200]}..." - {data["nombre"]}, {data["contexto"]}'
-            transcripciones_texto += transcripcion_texto + "\n"
-            transcripciones_brutas += transcripcion_texto + "\n\n"
+            transcription = transcribe_audio(data["audio"])
+            transcription_text = f'"{transcription}" - {data["name"]}, {data["position"]}'
+            raw_transcription = f'[Audio/Video {idx + 1}]: "{transcription}" - {data["name"]}, {data["position"]}'
+            transcriptions_text += transcription_text + "\n"
+            raw_transcriptions += raw_transcription + "\n\n"
+
+    for data in knowledge_base["social_content"]:
+        if data["text"]:
+            transcription_text = f'[Social media text]: "{data["text"][:200]}..." - {data["name"]}, {data["context"]}'
+            transcriptions_text += transcription_text + "\n"
+            raw_transcriptions += transcription_text + "\n\n"
         if data["video"]:
-            transcripcion_video = f'[Video de red social]: "{data["video"]}" - {data["nombre"]}, {data["contexto"]}'
-            transcripciones_texto += transcripcion_video + "\n"
-            transcripciones_brutas += transcripcion_video + "\n\n"
-
-    contenido_documentos = "\n\n".join(base_de_conocimiento["contenido_documentos"])
-    contenido_urls = "\n\n".join(base_de_conocimiento["contenido_urls"])
-
-    prompt_interno = """
-    Instrucciones para el modelo:
-    - Debes seguir los principios de una noticia: es decir, procura siempre responder las 5 W de una noticia en el primer párrafo (Who?, What?, When?, Where?, Why?).
-    - Asegúrate de que al menos el 80% de las citas sean directas y estén entrecomilladas.
-    - El 20% restante puede ser citas indirectas.
-    - No inventes información nueva.
-    - Sé riguroso con los hechos proporcionados.
-    - Al procesar los documentos cargados, extrae y resalta citas importantes y testimonios textuales de las fuentes.
-    - Al procesar los documentos cargados, extrae y resalta cifras clave.
-    - Evita usar la fecha al comienzo del cuerpo de la noticia. Empieza directamente con las 5W.
-    - Incluye el contenido de las redes sociales de manera relevante, citando la fuente y proporcionando el contexto adecuado.
-    - Asegúrate de relacionar el contexto proporcionado para el contenido de red social con su transcripción o texto correspondiente.
+            video_transcription = f'[Social media video]: "{data["video"]}" - {data["name"]}, {data["context"]}'
+            transcriptions_text += video_transcription + "\n"
+            raw_transcriptions += video_transcription + "\n\n"
+
+    document_content = "\n\n".join(knowledge_base["document_content"])
+    url_content = "\n\n".join(knowledge_base["url_content"])
+
+    internal_prompt = """
+    Instructions for the model:
+    - Follow the principles of news writing: always try to answer the 5 Ws of a news story in the first paragraph (Who?, What?, When?, Where?, Why?).
+    - Ensure that at least 80% of the quotes are direct and in quotation marks.
+    - The remaining 20% can be indirect quotes.
+    - Do not invent new information.
+    - Be rigorous with the provided facts.
+    - When processing uploaded documents, extract and highlight important quotes and verbatim testimonies from sources.
+    - When processing uploaded documents, extract and highlight key figures.
+    - Avoid using the date at the beginning of the news body. Start directly with the 5Ws.
+    - Include social media content relevantly, citing the source and providing appropriate context.
+    - Make sure to relate the provided context for social media content with its corresponding transcription or text.
     """
 
     prompt = f"""
-    {prompt_interno}
-    Escribe una noticia con la siguiente información, incluyendo un título, un gancho de 15 palabras (el gancho es lo que se conoce en inglés como hook, información adicional que complementa el título), y el cuerpo del contenido cuyo tamaño es {tamaño} palabras. El tono debe ser {tono}.
-    Instrucciones: {base_de_conocimiento["instrucciones"]}
-    Hechos: {base_de_conocimiento["hechos"]}
-    Contenido adicional de los documentos: {contenido_documentos}
-    Contenido adicional de las URLs: {contenido_urls}
-    Utiliza las siguientes transcripciones como citas directas e indirectas (sin cambiar ni inventar contenido):
-    {transcripciones_texto}
+    {internal_prompt}
+    Write a news article with the following information, including a title, a 15-word hook (additional information that complements the title), and the body content with a size of {size} words. The tone should be {tone}.
+    Instructions: {knowledge_base["instructions"]}
+    Facts: {knowledge_base["facts"]}
+    Additional content from documents: {document_content}
+    Additional content from URLs: {url_content}
+    Use the following transcriptions as direct and indirect quotes (without changing or inventing content):
+    {transcriptions_text}
     """
 
     try:
-        respuesta = openai.ChatCompletion.create(
+        response = openai.ChatCompletion.create(
             model="gpt-4o-mini",
             messages=[{"role": "user", "content": prompt}],
             temperature=0.1
         )
-        noticia = respuesta['choices'][0]['message']['content']
-        return noticia, transcripciones_brutas
+        news_article = response['choices'][0]['message']['content']
+        return news_article, raw_transcriptions
     except Exception as e:
-        logger.error(f"Error al generar la noticia: {str(e)}")
-        return f"Error al generar la noticia: {str(e)}", ""
+        logger.error(f"Error generating the news article: {str(e)}")
+        return f"Error generating the news article: {str(e)}", ""
 
 with gr.Blocks() as demo:
-    gr.Markdown("## Generador de noticias todo en uno")
+    gr.Markdown("## All-in-One News Generator")
     with gr.Row():
         with gr.Column(scale=2):
-            instrucciones = gr.Textbox(label="Instrucciones para la noticia", lines=2)
-            hechos = gr.Textbox(label="Describe los hechos de la noticia", lines=4)
-            tamaño = gr.Number(label="Tamaño del cuerpo de la noticia (en palabras)", value=100)
-            tono = gr.Dropdown(label="Tono de la noticia", choices=["serio", "neutral", "divertido"], value="neutral")
+            instructions = gr.Textbox(label="Instructions for the news article", lines=2)
+            facts = gr.Textbox(label="Describe the facts of the news", lines=4)
+            size = gr.Number(label="Size of the news body (in words)", value=100)
+            tone = gr.Dropdown(label="Tone of the news", choices=["serious", "neutral", "lighthearted"], value="neutral")
         with gr.Column(scale=3):
-            inputs_list = [instrucciones, hechos, tamaño, tono]
+            inputs_list = [instructions, facts, size, tone]
             with gr.Tabs():
                 for i in range(1, 6):
                     with gr.TabItem(f"Audio/Video {i}"):
                         file = gr.File(label=f"Audio/Video {i}", type="filepath", file_types=["audio", "video"])
-                        nombre = gr.Textbox(label="Nombre", scale=1)
-                        cargo = gr.Textbox(label="Cargo", scale=1)
-                        inputs_list.extend([file, nombre, cargo])
+                        name = gr.Textbox(label="Name", scale=1)
+                        position = gr.Textbox(label="Position", scale=1)
+                        inputs_list.extend([file, name, position])
                 for i in range(1, 4):
-                    with gr.TabItem(f"Red Social {i}"):
-                        social_url = gr.Textbox(label=f"URL de red social {i}", lines=1)
-                        social_nombre = gr.Textbox(label=f"Nombre de persona/cuenta {i}", scale=1)
-                        social_contexto = gr.Textbox(label=f"Contexto del contenido {i}", lines=2)
-                        inputs_list.extend([social_url, social_nombre, social_contexto])
+                    with gr.TabItem(f"Social Media {i}"):
+                        social_url = gr.Textbox(label=f"Social media URL {i}", lines=1)
+                        social_name = gr.Textbox(label=f"Person/account name {i}", scale=1)
+                        social_context = gr.Textbox(label=f"Content context {i}", lines=2)
+                        inputs_list.extend([social_url, social_name, social_context])
                 for i in range(1, 6):
                     with gr.TabItem(f"URL {i}"):
                         url = gr.Textbox(label=f"URL {i}", lines=1)
                         inputs_list.append(url)
                 for i in range(1, 6):
-                    with gr.TabItem(f"Documento {i}"):
-                        documento = gr.File(label=f"Documento {i}", type="filepath", file_count="single")
-                        inputs_list.append(documento)
+                    with gr.TabItem(f"Document {i}"):
+                        document = gr.File(label=f"Document {i}", type="filepath", file_count="single")
+                        inputs_list.append(document)
 
-    gr.Markdown("---")  # Separador visual
+    gr.Markdown("---")  # Visual separator
 
     with gr.Row():
-        transcripciones_output = gr.Textbox(label="Transcripciones", lines=10)
+        transcriptions_output = gr.Textbox(label="Transcriptions", lines=10)
 
-    gr.Markdown("---")  # Separador visual
+    gr.Markdown("---")  # Visual separator
 
     with gr.Row():
-        generar = gr.Button("Generar borrador")
+        generate = gr.Button("Generate draft")
     with gr.Row():
-        noticia_output = gr.Textbox(label="Borrador generado", lines=20)
+        news_output = gr.Textbox(label="Generated draft", lines=20)
 
-    generar.click(fn=generar_noticia, inputs=inputs_list, outputs=[noticia_output, transcripciones_output])
+    generate.click(fn=generate_news, inputs=inputs_list, outputs=[news_output, transcriptions_output])
 
-demo.launch(share=True)
+demo.launch(share=True)