HF Readme

.gitattributes

@@ -0,0 +1,2 @@
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,3 +1,8 @@
 /venv/
 /media/
-/resultados/
+/resultados/
+bridges.py
+/__pycache__/
+*.mp4
+/audio_tests/
+*.wav

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.MD

@@ -0,0 +1,11 @@
+---
+title: GenVid
+emoji: 📽️
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: true
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,178 @@
+import os
+from io import BytesIO
+from typing import List
+import funciones.motion as motion
+import tempfile
+from fastapi import FastAPI, Form
+from fastapi import FastAPI, File, UploadFile, HTTPException, status, BackgroundTasks
+from fastapi.responses import StreamingResponse, FileResponse, JSONResponse
+import herramientas
+
+app = FastAPI()
+
+@app.get("/health",
+         tags=["Monitoreo Server"],
+         description="Verifica el estado de salud de la API.",
+         summary="Health Check"
+         )
+async def health_check():
+    """
+    Este endpoint devuelve una respuesta 200 OK para indicar que la API está funcionando.
+    """
+    return JSONResponse(content={"status": "ok"}, status_code=200)
+
+@app.post("/echo-image/",
+          tags=["Monitoreo Server"],
+          description="Test endpoint para prueba de envío de imagenes.",
+          summary="Mirror test para envío de imagenes"
+          )
+async def echo_image(image: UploadFile = File(...)):
+    if not image.content_type.startswith("image/"):
+        return {"error": "El archivo no es una imagen"}
+    contents = await image.read()
+    return StreamingResponse(BytesIO(contents), media_type=image.content_type)
+
+@app.post("/motion-image/")
+async def motion_image(image: UploadFile = File(...), background_tasks: BackgroundTasks = BackgroundTasks()):
+    """
+    Recibe una imagen, la procesa con motion(), le da movimiento y devuelve el resultado.
+    """
+    if not image.content_type.startswith("image/"):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="El archivo no es una imagen. Por favor, suba una imagen."
+        )
+
+    temp_image_path = None # Inicializamos la variable para el bloque finally
+    output_file_generated = False # Flag para saber si monomotion generó un archivo
+
+    try:
+        # 1. Guardar la imagen subida en un archivo temporal
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{image.filename}") as tmp_file:
+            contents = await image.read()
+            tmp_file.write(contents)
+            temp_image_path = tmp_file.name
+        
+        print(f"Imagen subida guardada temporalmente en: {temp_image_path}")
+
+        # 2. Ejecutar motion()
+        # Asumimos que motion devuelve la ruta a un archivo de salida
+        path_archivo = await motion.motion(temp_image_path)
+        print("Salí de monomotion con resultado: ", path_archivo)
+        output_file_generated = True # Si llegamos aquí, asumimos que se generó un archivo
+
+        # 3. Determinar el tipo MIME del archivo de salida (si es diferente al de entrada)
+        # Esto es importante si motion cambia el formato (ej. de JPG a MP4)
+        import mimetypes
+        mimetypes.add_type("video/mp4", ".mp4") # Asegúrate de añadir tipos si esperas video
+        mime_type, _ = mimetypes.guess_type(path_archivo)
+        if not mime_type:
+             mime_type = "application/octet-stream" # Tipo genérico si no se puede adivinar
+
+        # 4.5 Programar la eliminación de AMBOS archivos después de que la respuesta sea enviada
+        # El archivo de entrada se borrará sí o sí.
+        background_tasks.add_task(herramientas.delete_file_on_complete, temp_image_path)
+        # El archivo de salida también se borrará, asumiendo que es temporal y solo para esta respuesta.
+        background_tasks.add_task(herramientas.delete_file_on_complete, path_archivo)
+
+        # 4. Devolver el archivo procesado al cliente
+        return FileResponse(
+            path=path_archivo,
+            media_type=mime_type,
+            filename=os.path.basename(path_archivo)
+        )
+
+    except HTTPException:
+        # Re-lanza cualquier HTTPException ya creada (ej. el 400 inicial)
+        raise
+    except Exception as e:
+        # Captura cualquier otro error inesperado durante el proceso
+        print(f"Error inesperado en /generate-monomotion-image/: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Ha ocurrido un error interno al procesar la imagen con monomotion: {e}"
+        )
+    finally:
+        # 5. Limpieza: Eliminar archivos temporales
+        # Eliminar la imagen de entrada temporal
+        if temp_image_path and os.path.exists(temp_image_path):
+            try:
+                os.remove(temp_image_path)
+                print(f"Archivo temporal de entrada eliminado: {temp_image_path}")
+            except Exception as cleanup_e:
+                print(f"Error al eliminar el archivo temporal de entrada {temp_image_path}: {cleanup_e}")
+
+@app.post("/echo-random-file/")
+async def echo_random_file(files: List[UploadFile] = File(...)):
+    """
+    Recibe múltiples archivos, selecciona uno al azar y lo devuelve.
+    """
+    if not files:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No se enviaron archivos."
+        )
+    
+    temp_file_paths = [] # Lista para guardar las rutas de los archivos temporales
+    try:
+        # 1. Guardar cada UploadFile en un archivo temporal en disco
+        for uploaded_file in files:
+            # Creamos un archivo temporal con un sufijo para mantener la extensión
+            # delete=False para que no se elimine inmediatamente al cerrar el archivo.
+            # Lo eliminaremos explícitamente en el bloque finally.
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{uploaded_file.filename}") as tmp_file:
+                contents = await uploaded_file.read()
+                tmp_file.write(contents)
+                current_temp_path = tmp_file.name
+                temp_file_paths.append(current_temp_path)
+                print(f"Guardado temporalmente: {current_temp_path}")
+        
+        # 2. Pasar la lista de rutas de archivos temporales a tu función 'cinema'
+        # ¡Ahora 'lista_rutas_archivos' es la "lista" que tu función cinema espera!
+        resultado_cinema = await motion.cinema(temp_file_paths)
+
+        # 3. Manejar el resultado de la función 'cinema'
+        if isinstance(resultado_cinema, str):
+            # Si cinema devuelve una ruta a un archivo (ej. un video generado)
+            # Determinar el tipo MIME del archivo de salida
+            import mimetypes
+            mime_type, _ = mimetypes.guess_type(resultado_cinema)
+            if not mime_type:
+                 mime_type = "application/octet-stream" # Tipo genérico si no se puede adivinar
+
+            # Devolver el archivo generado por cinema
+            # Asegúrate de que este archivo también se gestione y elimine si es temporal
+            return FileResponse(
+                path=resultado_cinema,
+                media_type=mime_type,
+                filename=os.path.basename(resultado_cinema)
+            )
+        elif isinstance(resultado_cinema, dict) and "error" in resultado_cinema:
+            # Si cinema devuelve un diccionario de error
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Error en la función cinema: {resultado_cinema['error']}"
+            )
+        else:
+            # Si cinema devuelve otra cosa (ej. un JSON de éxito sin archivo)
+            return resultado_cinema # Asume que es un diccionario JSON serializable
+
+    except HTTPException:
+        # Re-lanza cualquier HTTPException que ya se haya levantado (ej. por validación de entrada)
+        raise
+    except Exception as e:
+        # Captura cualquier otro error inesperado
+        print(f"Error inesperado en /process-files-with-cinema/: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Ha ocurrido un error interno al procesar los archivos con cinema: {e}"
+        )
+    finally:
+        # 4. Limpiar los archivos temporales creados
+        for path in temp_file_paths:
+            if os.path.exists(path):
+                try:
+                    os.remove(path)
+                    print(f"Archivo temporal eliminado: {path}")
+                except Exception as cleanup_e:
+                    print(f"Error al eliminar el archivo temporal {path}: {cleanup_e}")   

audio_tests/audioHF.py

@@ -0,0 +1,29 @@
+from transformers import pipeline
+from datasets import load_dataset
+import soundfile as sf
+import torch
+import time
+
+synthesiser = pipeline("text-to-speech", "microsoft/speecht5_tts")
+#synthesiser = pipeline("text-to-speech", "Sandiago21/speecht5_finetuned_facebook_voxpopuli_spanish") 
+#synthesiser = pipeline("text-to-speech", "jjyaoao/speecht5_voxpopuli_spanish")
+
+embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
+speaker_embedding = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
+# You can replace this embedding with your own as well.
+
+dialogo = """
+Las piedras preciosas son, en esencia, minerales, rocas o materiales orgánicos que han sido seleccionados por su 
+belleza, durabilidad y rareza, lo que les confiere un gran valor. Son objetos de deseo y admiración desde hace milenios, 
+utilizados en joyería, objetos de arte y como símbolos de estatus o poder.
+"""
+
+unix_timestamp_float = time.time()
+start_time = time.time()  # Registra el tiempo de inicio
+speech = synthesiser("Lo del puto perro", forward_params={"speaker_embeddings": speaker_embedding})
+end_time = time.time()    # Registra el tiempo de finalización
+
+# Calcula la duración
+duration = end_time - start_time
+
+sf.write(f"audioHF_ms_{unix_timestamp_float}_{duration}s.wav", speech["audio"], samplerate=speech["sampling_rate"])

audio_tests/audioMELO.py

@@ -0,0 +1,15 @@
+from melo.api import TTS
+
+# Speed is adjustable
+speed = 1.0
+
+# CPU is sufficient for real-time inference.
+# You can also change to cuda:0
+device = 'cpu'
+
+text = "El resplandor del sol acaricia las olas, pintando el cielo con una paleta deslumbrante."
+model = TTS(language='ES', device=device)
+speaker_ids = model.hps.data.spk2id
+
+output_path = 'es.wav'
+model.tts_to_file(text, speaker_ids['ES'], output_path, speed=speed)

audio_tests/audioMS.py

@@ -0,0 +1,14 @@
+from transformers import pipeline
+from datasets import load_dataset
+import soundfile as sf
+import torch
+
+synthesiser = pipeline(task="text-to-speech", model="microsoft/speecht5_tts")
+
+embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
+speaker_embedding = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
+# You can replace this embedding with your own as well.
+
+speech = synthesiser("Hello, my dog is cooler than you!", forward_params={"speaker_embeddings": speaker_embedding})
+
+sf.write("speech.wav", speech["audio"], samplerate=speech["sampling_rate"])

audio_tests/audioOpen.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from openai import OpenAI
+import bridges
+
+client = OpenAI(api_key=bridges.llave) #Usa Buzzword (buzz) o Moibe (llave).
+speech_file_path = Path(__file__).parent / "speech.mp3"
+
+with client.audio.speech.with_streaming_response.create(
+    model="gpt-4o-mini-tts",
+    voice="coral",
+    input="Today is a wonderful day to build something people love!",
+    instructions="Speak in a cheerful and positive tone.",
+) as response:
+    response.stream_to_file(speech_file_path)

audio_tests/audioOpenAI.py

@@ -0,0 +1,24 @@
+import asyncio
+
+from openai import AsyncOpenAI
+from openai.helpers import LocalAudioPlayer
+
+openai = AsyncOpenAI()
+
+input = """Yeah, yeah, ya got Big Apple Insurance, whaddaya need? Let's make this quick, I got places to be.\n\nIf ya gotta file a claim, press 1—lemme guess, someone cut ya off? Figures.\n\nWanna check the status? Press 2, I know, I know, hurry it up, right?\n\nIf ya just wanna hold, press 3—hey, your call, but don't say I didn't warn ya.\n\nNeed a real person? Press 4, and I'll get ya through—just don't start yellin' at 'em, they're doin' their best.\n\nAlright, let's move it along, time is money, buddy!"""
+
+instructions = """Voice: Gruff, fast-talking, and a little worn-out, like a New York cabbie who's seen it all but still keeps things moving.\n\nTone: Slightly exasperated but still functional, with a mix of sarcasm and no-nonsense efficiency.\n\nDialect: Strong New York accent, with dropped \"r\"s, sharp consonants, and classic phrases like whaddaya and lemme guess.\n\nPronunciation: Quick and clipped, with a rhythm that mimics the natural hustle of a busy city conversation.\n\nFeatures: Uses informal, straight-to-the-point language, throws in some dry humor, and keeps the energy just on the edge of impatience but still helpful."""
+
+async def main() -> None:
+
+    async with openai.audio.speech.with_streaming_response.create(
+        model="gpt-4o-mini-tts",
+        voice="echo",
+        input=input,
+        instructions=instructions,
+        response_format="pcm",
+    ) as response:
+        await LocalAudioPlayer().play(response)
+
+if __name__ == "__main__":
+    asyncio.run(main())

busqueda.py

@@ -0,0 +1,68 @@
+from googleapiclient.discovery import build
+
+# --- Configura tus credenciales y ID de Motor de Búsqueda ---
+API_KEY = "AIzaSyDjsiJLlUwtHaCCBQUwcFCqlN5Nu5wJluw"  # Reemplaza con tu Clave de API de Google Cloud
+CX = "90556d12415d84063" # Reemplaza con el ID de tu Custom Search Engine
+
+def buscar_imagenes_google(query, num_results=5):
+    """
+    Realiza una búsqueda de imágenes en Google usando la Custom Search API.
+
+    Args:
+        query (str): El término de búsqueda.
+        num_results (int): El número máximo de resultados a devolver (máx. 10 por solicitud).
+
+    Returns:
+        list: Una lista de diccionarios, donde cada diccionario representa una imagen
+              y contiene su URL, título, etc.
+    """
+    try:
+        # Construye el servicio de la API de Custom Search
+        # 'customsearch' es el nombre del servicio, 'v1' es la versión
+        service = build("customsearch", "v1", developerKey=API_KEY)
+
+        # Ejecuta la búsqueda.
+        # 'q': el término de búsqueda
+        # 'cx': el ID de tu Custom Search Engine
+        # 'searchType': MUY IMPORTANTE, para especificar que buscas imágenes
+        # 'num': número de resultados (máx. 10 por solicitud, aunque puedes paginar)
+        res = service.cse().list(
+            q=query,
+            cx=CX,
+            searchType='image',
+            num=num_results
+        ).execute()
+
+        # Extrae los resultados
+        items = res.get('items', [])
+        
+        resultados_imagenes = []
+        for item in items:
+            resultados_imagenes.append({
+                'title': item.get('title'),
+                'link': item.get('link'),  # URL directa de la imagen
+                'displayLink': item.get('displayLink'), # URL del sitio donde se encontró
+                'thumbnailLink': item['image'].get('thumbnailLink') if 'image' in item else None # URL de la miniatura
+            })
+        
+        return resultados_imagenes
+
+    except Exception as e:
+        print(f"Ocurrió un error: {e}")
+        return []
+
+# --- Ejemplo de uso ---
+if __name__ == "__main__":
+    termino_busqueda = "Japan Mt Fuji"
+    imagenes_encontradas = buscar_imagenes_google(termino_busqueda, num_results=3)
+
+    if imagenes_encontradas:
+        print(f"Imágenes encontradas para '{termino_busqueda}':")
+        for i, imagen in enumerate(imagenes_encontradas):
+            print(f"--- Imagen {i+1} ---")
+            print(f"Título: {imagen.get('title')}")
+            print(f"URL: {imagen.get('link')}")
+            print(f"URL Miniatura: {imagen.get('thumbnailLink')}")
+            print("-" * 20)
+    else:
+        print("No se encontraron imágenes o hubo un error.")

funciones/motion.py

@@ -0,0 +1,66 @@
+import time
+import subprocess
+import herramientas
+
+
+async def motion(imagen):
+
+    current_timestamp_int = int(time.time())
+    print("Ésto es current time stamp: ", current_timestamp_int)
+
+    print("Esto es imagen en monomotion: ", imagen)
+
+    ffmpeg_command = [
+                            'ffmpeg', '-y',
+                            '-loop', '1',
+                            '-i', 
+                            f'{imagen}',
+                            '-t', str(3),
+                            '-vf',
+                            f"scale=1280:720:force_original_aspect_ratio=increase,"
+                            f"crop=1280:720,"
+                            f"zoompan=z='zoom+0.0005':d=1500", #al zoom actual le vas a aumentar 
+                            '-r', str(25),
+                            '-pix_fmt', 'yuv420p',
+                            '-c:v', 'libx264',
+                            '-preset', 'fast',
+                            '-movflags', '+faststart',  # Agregar esta línea
+                            f'resultados/{current_timestamp_int}.mp4'
+                        ]
+    
+    print("Comando:")
+    print(ffmpeg_command)
+    
+    subprocess.run(ffmpeg_command, check=True)
+
+    return f'resultados/{current_timestamp_int}.mp4'
+
+async def cinema(lista):
+
+    lista = herramientas.lista_archivos('media')
+    print("Ésto es lista:", lista)    
+
+    for elemento in lista: 
+
+        ffmpeg_command = [
+                                'ffmpeg', '-y',
+                                '-loop', '1',
+                                '-i', 
+                                f'media/{elemento}',
+                                '-t', str(3),
+                                '-vf',
+                                f"scale=1280:720:force_original_aspect_ratio=increase,"
+                                f"crop=1280:720,"
+                                f"zoompan=z='zoom+0.0005':d=1500", #al zoom actual le vas a aumentar 
+                                '-r', str(25),
+                                '-pix_fmt', 'yuv420p',
+                                '-c:v', 'libx264',
+                                '-preset', 'fast',
+                                '-movflags', '+faststart',  # Agregar esta línea
+                                f'resultados1/{elemento}.mp4'
+                            ]
+        
+        print("Comando:")
+        print(ffmpeg_command)
+        
+        subprocess.run(ffmpeg_command, check=True)

funciones_old.py

@@ -0,0 +1,186 @@
+import io
+import time
+import globales
+import random
+import herramientas
+import gradio_client
+from fastapi import HTTPException, status
+from huggingface_hub import InferenceClient
+
+
+servidor = globales.servidor
+
+def procesa_dni(platillo):
+
+    print("Estoy en procesa DNI...")
+
+    print("Y esto es contents: ", platillo)
+
+    time.sleep(18)
+
+    prompt = globales.previo + platillo
+    print("Platillo enviado:", platillo) 
+
+    try:
+
+        dict_espacios = conexion_firebase.obtenDato('nowme', servidor, 'espacios')
+
+        espacios_habilitados = [
+        nombre for nombre, config in dict_espacios.items()
+        if config.get("habilitado", False) # Usamos .get() para evitar KeyError si 'habilitado' no existe
+        ]
+
+        print(f"Espacios habilitados: {espacios_habilitados}")
+        
+        espacio_aleatorio_elegido = random.choice(espacios_habilitados)
+        configuracion_espacio = dict_espacios[espacio_aleatorio_elegido]
+        print(f"La configuración completa para '{espacio_aleatorio_elegido}' es: {configuracion_espacio}")
+
+        client = gradio_client.Client(configuracion_espacio['ruta'], hf_token=globales.llave)
+        #kwargs = selected_space_config['static_kwargs']
+
+        result = client.predict(
+        #**kwargs,
+        prompt=prompt,
+        #negative_prompt="live animals",
+        # seed=42,
+        # randomize_seed=True,
+        width=786,
+        height=568,
+        # guidance_scale=3.5,
+        # num_inference_steps=28,
+        api_name=configuracion_espacio['api_name']       
+        )
+
+        #Cuando es GPU, debe de restar segundos disponibles de HF 
+        herramientas.restaSegundosGPU(globales.work_cost)
+
+        print("Platillo generado:", platillo)
+        return result[0]
+
+    except Exception as e:     
+        print("Excepción: ", e)        
+        # Opción para regresar imagen genérica. (ya no porque se envía desde backend.)
+        # return "default.png"
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=e
+        )
+
+def genera_platillo_gpu(platillo):
+
+    prompt = globales.previo + platillo
+    print("Platillo enviado:", platillo) 
+
+    try:
+
+        dict_espacios = conexion_firebase.obtenDato('nowme', servidor, 'espacios')
+
+        espacios_habilitados = [
+        nombre for nombre, config in dict_espacios.items()
+        if config.get("habilitado", False) # Usamos .get() para evitar KeyError si 'habilitado' no existe
+        ]
+
+        print(f"Espacios habilitados: {espacios_habilitados}")
+        
+        espacio_aleatorio_elegido = random.choice(espacios_habilitados)
+        configuracion_espacio = dict_espacios[espacio_aleatorio_elegido]
+        print(f"La configuración completa para '{espacio_aleatorio_elegido}' es: {configuracion_espacio}")
+
+        client = gradio_client.Client(configuracion_espacio['ruta'], hf_token=globales.llave)
+        #kwargs = selected_space_config['static_kwargs']
+
+        result = client.predict(
+        #**kwargs,
+        prompt=prompt,
+        #negative_prompt="live animals",
+        # seed=42,
+        # randomize_seed=True,
+        width=786,
+        height=568,
+        # guidance_scale=3.5,
+        # num_inference_steps=28,
+        api_name=configuracion_espacio['api_name']       
+        )
+
+        #Cuando es GPU, debe de restar segundos disponibles de HF 
+        herramientas.restaSegundosGPU(globales.work_cost)
+
+        print("Platillo generado:", platillo)
+        return result[0]
+
+    except Exception as e:     
+        print("Excepción: ", e)        
+        # Opción para regresar imagen genérica. (ya no porque se envía desde backend.)
+        # return "default.png"
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=e
+        )
+
+def genera_platillo_inference(platillo):
+
+    dict_modelos = conexion_firebase.obtenDato('nowme', servidor, 'modelos')
+
+    modelos_habilitados = [
+        nombre for nombre, config in dict_modelos.items()
+        if config.get("habilitado", False) # Usamos .get() para evitar KeyError si 'habilitado' no existe
+        ]
+    
+    print(f"Modelos habilitados: {modelos_habilitados}")
+
+    modelo_aleatorio_elegido = random.choice(modelos_habilitados)
+    configuracion_modelo = dict_modelos[modelo_aleatorio_elegido]
+    print(f"La configuración completa para '{modelo_aleatorio_elegido}' es: {configuracion_modelo}")
+
+
+    creditos_restantes_inference = conexion_firebase.obtenDato('nowme', servidor, 'inferencias')
+    
+    #print("Los créditos restantes de hf-inference que tienes son: ", creditos_restantes_inference)
+    if creditos_restantes_inference > 0:
+        provedor_seleccionado = globales.proveedor
+    else:
+        provedor_seleccionado = globales.proveedor_back
+
+    prompt = globales.previo + platillo
+    print("Platillo enviado:", platillo)
+       
+    client = InferenceClient(
+            provider= provedor_seleccionado,
+            model=configuracion_modelo['ruta'],
+            api_key=globales.llave
+        )    
+    
+    print("Cree cliente: ", client)
+    time.sleep(0)
+
+    try: 
+        image = client.text_to_image(
+        prompt,
+        #negative_prompt="live animals",        
+        width=784, #786
+        height=560, #568
+        num_inference_steps=16
+        ) 
+
+        #Detenido momentaneamente por cambio a firebase.
+        herramientas.restaSegundosInference(globales.inference_cost)              
+        
+    except Exception as e:
+        print("Excepción: ", e)
+        if "Gateway Time-out" in str(e): 
+            print("GATEWAY TIME-OUT 💀")
+            #modelo=globales.inferencia_backup #Con el nuevo paradigma ya no hay cambio de modelo.
+            #Escribe en txt el nuevo modelo.
+            #herramientas.modificaModeloActual(modelo)        
+        error_impreso = f"Error: {e}"
+        print(error_impreso)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        )
+    
+    img_io = io.BytesIO()
+    image.save(img_io, "PNG")
+    img_io.seek(0)
+    print("Platillo generado:", platillo)
+    return img_io    

guardaImagenes.py

@@ -0,0 +1,74 @@
+from googleapiclient.discovery import build
+import bridges
+import time
+
+# --- Configura tus credenciales y ID de Motor de Búsqueda ---
+API_KEY = bridges.google_api  # Reemplaza con tu Clave de API de Google Cloud
+CX = "90556d12415d84063" # Reemplaza con el ID de tu Custom Search Engine
+
+def buscar_imagenes_google(query, num_results=5):
+    """
+    Realiza una búsqueda de imágenes en Google usando la Custom Search API.
+
+    Args:
+        query (str): El término de búsqueda.
+        num_results (int): El número máximo de resultados a devolver (máx. 10 por solicitud).
+
+    Returns:
+        list: Una lista de diccionarios, donde cada diccionario representa una imagen
+              y contiene su URL, título, etc.
+    """
+    try:
+        # Construye el servicio de la API de Custom Search
+        # 'customsearch' es el nombre del servicio, 'v1' es la versión
+        service = build("customsearch", "v1", developerKey=API_KEY)
+
+        # Ejecuta la búsqueda.
+        # 'q': el término de búsqueda
+        # 'cx': el ID de tu Custom Search Engine
+        # 'searchType': MUY IMPORTANTE, para especificar que buscas imágenes
+        # 'num': número de resultados (máx. 10 por solicitud, aunque puedes paginar)
+        res = service.cse().list(
+            q=query,
+            cx=CX,
+            searchType='image',
+            num=num_results
+        ).execute()
+
+        print("Esto es res:")
+        print(res)
+        time.sleep(18)
+
+        # Extrae los resultados
+        items = res.get('items', [])
+        
+        resultados_imagenes = []
+        for item in items:
+            resultados_imagenes.append({
+                'title': item.get('title'),
+                'link': item.get('link'),  # URL directa de la imagen
+                'displayLink': item.get('displayLink'), # URL del sitio donde se encontró
+                'thumbnailLink': item['image'].get('thumbnailLink') if 'image' in item else None # URL de la miniatura
+            })
+        
+        return resultados_imagenes
+
+    except Exception as e:
+        print(f"Ocurrió un error: {e}")
+        return []
+
+# --- Ejemplo de uso ---
+if __name__ == "__main__":
+    termino_busqueda = "Mexico Day of the Dead"
+    imagenes_encontradas = buscar_imagenes_google(termino_busqueda, num_results=3)
+
+    if imagenes_encontradas:
+        print(f"Imágenes encontradas para '{termino_busqueda}':")
+        for i, imagen in enumerate(imagenes_encontradas):
+            print(f"--- Imagen {i+1} ---")
+            print(f"Título: {imagen.get('title')}")
+            print(f"URL: {imagen.get('link')}")
+            print(f"URL Miniatura: {imagen.get('thumbnailLink')}")
+            print("-" * 20)
+    else:
+        print("No se encontraron imágenes o hubo un error.")

herramientas.py

@@ -0,0 +1,46 @@
+import os
+
+def lista_archivos(directorio):
+    nombres_archivos = []  # Inicializamos una lista vacía para guardar los nombres
+
+    try:
+        # Verificar si la carpeta existe
+        if os.path.exists(directorio) and os.path.isdir(directorio):
+            # Listar todos los elementos dentro de la carpeta
+            elementos = os.listdir(directorio)
+
+            print(f"Archivos encontrados en la carpeta '{directorio}':")
+            for elemento in elementos:
+                ruta_completa = os.path.join(directorio, elemento)
+                # Verificar si el elemento es un archivo
+                if os.path.isfile(ruta_completa):
+                    nombres_archivos.append(elemento)  # Añadir el nombre del archivo a la lista
+                    print(elemento)  # Opcional: imprimir el nombre mientras se guarda
+
+            print("\nLista de nombres de archivos guardada en la variable 'nombres_archivos'.")
+            # Ahora la variable 'nombres_archivos' contiene todos los nombres de los archivos
+            # que puedes usar en el resto de tu código.
+            # Ejemplo de cómo podrías acceder a los nombres:
+            # for nombre in nombres_archivos:
+            #     print(f"Procesando archivo: {nombre}")
+
+            return nombres_archivos
+
+        else:
+            print(f"La carpeta '{directorio}' no existe o no es un directorio.")
+            nombres_archivos = []  # Asegurarse de que la lista esté vacía en caso de error
+            return nombres_archivos
+
+    except Exception as e:
+        print(f"Ocurrió un error al acceder a la carpeta: {e}")
+        nombres_archivos = []  # Asegurarse de que la lista esté vacía en caso de error
+        return nombres_archivos
+    
+def delete_file_on_complete(path: str):
+    """Callback para borrar un archivo después de que la respuesta se haya enviado."""
+    if os.path.exists(path):
+        try:
+            os.remove(path)
+            print(f"Archivo eliminado correctamente en BackgroundTasks: {path}")
+        except Exception as e:
+            print(f"ERROR: No se pudo eliminar el archivo {path} en BackgroundTasks: {e}")

requirements.txt

@@ -0,0 +1,10 @@
+openai
+datasets
+openai[voice_helpers]
+transformers
+torch
+soundfile
+sentencepiece
+#melo.api
+google-api-python-client
+fastapi

run.py

@@ -1,19 +0,0 @@
-import subprocess
-
-ffmpeg_command = [
-                        'ffmpeg', '-y',
-                        '-loop', '1',
-                        '-i', 'media/tp.jpg',
-                        '-t', str(3),
-                        '-vf',
-                        # f"scale=16:9:force_original_aspect_ratio=increase,"
-                        # f"crop=16:9,"
-                        f"zoompan=z='zoom+0.0005':d=25*60",
-                        '-r', str(25),
-                        '-pix_fmt', 'yuv420p',
-                        '-c:v', 'libx264',
-                        '-preset', 'fast',
-                        'resultados/resultado.mp4'
-                    ]
-
-subprocess.run(ffmpeg_command, check=True)

stitcher.py

@@ -0,0 +1,86 @@
+import subprocess
+import herramientas
+import os
+
+def remux_video(input_path, output_path):
+    """Re-muxea un archivo de video MP4."""
+    ffmpeg_command_remux = [
+        'ffmpeg',
+        '-i', input_path,
+        '-c', 'copy',
+        '-movflags', '+faststart',
+        output_path
+    ]
+    try:
+        subprocess.run(ffmpeg_command_remux, check=True, capture_output=True)
+        print(f"Re-muxing exitoso de: {input_path} a {output_path}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Error al re-muxear {input_path}: {e}")
+        print(f"Salida de error de FFmpeg:\n{e.stderr.decode()}")
+        return False
+    except Exception as e:
+        print(f"Ocurrió un error durante el re-muxing: {e}")
+        return False
+    
+def unirVideos():
+
+    directorio_videos = 'resultados'
+    lista_nombres_archivos = herramientas.lista_archivos(directorio_videos)
+    archivos_remuxeados = []
+    lista_archivo_temporal = 'lista_concat.txt'
+
+    try:
+        with open(lista_archivo_temporal, 'w') as f_lista:
+            for nombre_archivo in lista_nombres_archivos:
+                ruta_completa = os.path.join(directorio_videos, nombre_archivo)
+                nombre_base, extension = os.path.splitext(nombre_archivo)
+                ruta_temporal = os.path.join(directorio_videos, f"temp_{nombre_base}{extension}")
+                if remux_video(ruta_completa, ruta_temporal):
+                    archivos_remuxeados.append(ruta_temporal)
+                    f_lista.write(f"file '{ruta_temporal}'\n")
+                else:
+                    print("Error al re-muxear un archivo. Abortando la creación de la lista.")
+                    archivos_remuxeados = []
+                    break
+    except FileNotFoundError as e:
+        print(f"Error al abrir o crear el archivo de lista temporal: {e}")
+        archivos_remuxeados = []
+    except Exception as e:
+        print(f"Ocurrió un error al escribir en el archivo de lista temporal: {e}")
+        archivos_remuxeados = []
+
+    if archivos_remuxeados:
+        ffmpeg_command_concat = [
+            'ffmpeg',
+            '-f', 'concat',
+            '-safe', '0',
+            '-i', lista_archivo_temporal,
+            '-an',
+            '-c', 'copy',
+            'video_unido_sin_audio.mp4'
+        ]
+
+        try:
+            subprocess.run(ffmpeg_command_concat, check=True, capture_output=True)
+            print("Los videos se han unido exitosamente (usando archivo de lista y archivos remuxeados).")
+        except subprocess.CalledProcessError as e:
+            print(f"Error al ejecutar FFmpeg para concatenar (archivo de lista): {e}")
+            print(f"Salida de error de FFmpeg:\n{e.stderr.decode()}")
+        except Exception as e:
+            print(f"Ocurrió un error durante la concatenación (archivo de lista): {e}")
+        finally:
+            # Limpiar los archivos temporales y el archivo de lista
+            for archivo_temporal in archivos_remuxeados:
+                try:
+                    os.remove(archivo_temporal)
+                    print(f"Archivo temporal eliminado: {archivo_temporal}")
+                except OSError as e:
+                    print(f"Error al eliminar el archivo temporal {archivo_temporal}: {e}")
+            try:
+                os.remove(lista_archivo_temporal)
+                print(f"Archivo de lista eliminado: {lista_archivo_temporal}")
+            except OSError as e:
+                print(f"Error al eliminar el archivo de lista {lista_archivo_temporal}: {e}")
+    else:
+        print("No se pudieron re-muxear los archivos o hubo un error al crear la lista, no se intentó la concatenación.")

test.py

@@ -0,0 +1,7 @@
+import herramientas
+import stitcher
+
+resultado = herramientas.lista_archivos('resultados')
+print("Ésta es la lista de nombres 182: ", resultado)
+
+stitcher.unirVideos()