Upload 23 files

Vidu/app.py

@@ -0,0 +1,562 @@
+import os
+import subprocess
+from PIL import Image
+import gradio as gr
+import cv2
+
+# Codigo creado por IA(Sistema de Interes) https://www.youtube.com/@IA.Sistema.de.Interes
+# Función para ejecutar comandos y devolver el estado
+def run_commands(description, aspect_ratio, enhance_check, model, style, upscale_check, task_type, img=None, is_extend=False, is_recreate=False):
+    try:
+        commands = []
+
+        if True:
+            # Comandos generales según el tipo de tarea
+            if upscale_check:
+                commands.append('python /content/Vidu_Studio/vidu_credit.py --credit 4')
+            else:
+                commands.append('python /content/Vidu_Studio/vidu_credit.py --credit 0')
+
+            if task_type == "video_to_video":
+                commands.append('python /content/Vidu_Studio/utils/video_fragment.py')
+                print("File  Uploader...")
+                commands.append('python /content/Vidu_Studio/upload/file_uploader.py --file_info "file_info" --image "img_fragmento"')
+
+            if task_type == "extend":
+                print("Last frame...")
+                commands.append('python /content/Vidu_Studio/utils/fragment.py')
+
+            if task_type == "reference_to_video" or task_type == "image_to_video" or task_type == "extend":
+                print("File  Uploader...")
+                commands.append('python /content/Vidu_Studio/upload/file_uploader.py --file_info "file_info" --image "img_fragmento"')
+
+            if task_type == "reference_to_video":
+                print("Generating video with reference...")
+                commands.append(
+                    f'python /content/Vidu_Studio/create_video_reference.py --prompt "{description}" --enhance {str(enhance_check).lower()} --model "{model}"'
+                )
+            elif task_type == "text_to_video":
+                print("Generating video: Text to Video...")
+                commands.append(
+                    f'python /content/Vidu_Studio/create_text_to_video.py --prompt "{description}" --enhance {str(enhance_check).lower()} --model "{model}" --style "{style}" --aspect_ratio "{aspect_ratio}"'
+                )
+            elif task_type == "image_to_video" or task_type == "extend":
+                print("Generating Video: Image to Video...")
+                commands.append(
+                    f'python /content/Vidu_Studio/create_task.py --prompt "{description}" --enhance {str(enhance_check).lower()} --model "{model}"'
+                )
+            elif task_type == "video_to_video":
+                print("Generating Video: Video to Video...")
+                commands.append(
+                    f'python /content/Vidu_Studio/create_task.py --prompt "{description}" --enhance {str(enhance_check).lower()} --model "{model}"'
+                )
+            else:
+                raise ValueError(f"Tipo de tarea no reconocido: {task_type}")
+            print("Video in progress...")
+            commands.append('python /content/Vidu_Studio/utils/process_task.py')
+
+            if upscale_check:
+                print("Generate Upscale...")
+                commands.append('python /content/Vidu_Studio/utils/upscale_task.py')
+                print("Upscale in progress...")
+                commands.append('python /content/Vidu_Studio/utils/process_task_upscale.py')
+                commands.append('python /content/Vidu_Studio/utils/delete_task.py')
+                commands.append('python /content/Vidu_Studio/utils/delete_task_upscale.py')
+            else:
+                commands.append('python /content/Vidu_Studio/utils/delete_task.py')
+
+        output = ""
+        for command in commands:
+            result = subprocess.run(command, shell=True, capture_output=True, text=True)
+            output += f"Exit:\n{result.stdout}\n"
+            print(result.stdout)
+
+        video_path = "/content/Vidu_Studio/video.mp4"
+        return output, video_path
+    except Exception as e:
+        return f"Excepción: {str(e)}", None
+
+
+
+
+
+
+
+
+def run_commands_dual(description, aspect_ratio, enhance_check, model, style, upscale_check, task_type, add_end_frame, img=None, is_extend=False, is_recreate=False):
+    try:
+        commands = []
+
+        if add_end_frame:
+            # Comandos generales según el tipo de tarea
+            if upscale_check:
+                commands.append('python /content/Vidu_Studio/vidu_credit.py --credit 4')
+            else:
+                commands.append('python /content/Vidu_Studio/vidu_credit.py --credit 0')
+
+            print("File  Uploader...")
+            commands.append('python /content/Vidu_Studio/upload/file_uploader.py --file_info "file_info" --image "img_fragmento"')
+            commands.append('python /content/Vidu_Studio/upload/file_uploader.py --file_info "file_info2" --image "img_fragmento2"')
+
+            if task_type == "headtailimg2video":
+                print("Generating video with headtailimg2video...")
+                commands.append(
+                    f'python /content/Vidu_Studio/headtailimg2video.py --prompt "{description}" --enhance {str(enhance_check).lower()} --model "{model}"'
+                )
+            print("Video in progress...")
+            commands.append('python /content/Vidu_Studio/utils/process_task.py')
+            
+            if upscale_check:
+                print("Generate Upscale...")
+                commands.append('python /content/Vidu_Studio/utils/upscale_task.py')
+                print("Upscale in progress...")
+                commands.append('python /content/Vidu_Studio/utils/process_task_upscale.py')
+                commands.append('python /content/Vidu_Studio/utils/delete_task.py')
+                commands.append('python /content/Vidu_Studio/utils/delete_task_upscale.py')
+            else:
+                commands.append('python /content/Vidu_Studio/utils/delete_task.py')
+        else:
+            # Comandos generales según el tipo de tarea
+            if upscale_check:
+                commands.append('python /content/Vidu_Studio/vidu_credit.py --credit 4')
+            else:
+                commands.append('python /content/Vidu_Studio/vidu_credit.py --credit 0')
+
+            print("File  Uploader...")
+            commands.append('python /content/Vidu_Studio/upload/file_uploader.py --file_info "file_info" --image "img_fragmento"')
+
+            if task_type == "headtailimg2video":
+                print("Generating video with Image to Video...")
+                commands.append(
+                    f'python /content/Vidu_Studio/create_task.py --prompt "{description}" --enhance {str(enhance_check).lower()} --model "{model}"'
+                )
+            
+            print("Video in progress...")
+            commands.append('python /content/Vidu_Studio/utils/process_task.py')
+            
+            if upscale_check:
+                print("Generate Upscale...")
+                commands.append('python /content/Vidu_Studio/utils/upscale_task.py')
+                print("Upscale in progress...")
+                commands.append('python /content/Vidu_Studio/utils/process_task_upscale.py')
+                commands.append('python /content/Vidu_Studio/utils/delete_task.py')
+                commands.append('python /content/Vidu_Studio/utils/delete_task_upscale.py')
+            else:
+                commands.append('python /content/Vidu_Studio/utils/delete_task.py')
+
+
+        output = ""
+        for command in commands:
+            result = subprocess.run(command, shell=True, capture_output=True, text=True)
+            output += f"Exit:\n{result.stdout}\n"
+            print(result.stdout)
+
+        video_path = "/content/Vidu_Studio/video.mp4"
+        return output, video_path
+    except Exception as e:
+        return f"Excepción: {str(e)}", None
+
+# Función para procesar y guardar la imagen automáticamente en formato JPG
+def process_and_save_image(image, coordinates_file_path="/tmp/coordinates.txt"):
+    jpg_path = "/tmp/img_fragmento.jpg"
+
+    try:
+        if image.format != "JPEG":
+            image = image.convert("RGB")
+        image.save(jpg_path, "JPEG", quality=100)
+        if os.path.exists(jpg_path):
+            print(f"Imagen guardada correctamente")
+
+            # Obtener las dimensiones de la imagen
+            width, height = image.size
+
+            # Guardar las coordenadas en un archivo de texto
+            with open(coordinates_file_path, "w") as file:
+                file.write(f"X: {width}\n")
+                file.write(f"Y: {height}\n")
+
+            print(f"Coordenadas guardadas correctamente")
+
+        return None
+    except Exception as e:
+        print(f"Error al procesar la imagen: {str(e)}")
+        return None
+
+# Función para procesar y guardar la imagen automáticamente en formato JPG
+def process_and_save_image1(image, coordinates_file_path="/tmp/coordinates.txt"):
+    jpg_path = "/tmp/img_fragmento.jpg"
+
+    try:
+        if image.format != "JPEG":
+            image = image.convert("RGB")
+        image.save(jpg_path, "JPEG", quality=100)
+        if os.path.exists(jpg_path):
+            print(f"Imagen guardada correctamente")
+
+            # Obtener las dimensiones de la imagen
+            width, height = image.size
+
+            # Guardar las coordenadas en un archivo de texto
+            with open(coordinates_file_path, "w") as file:
+                file.write(f"X: {width}\n")
+                file.write(f"Y: {height}\n")
+
+            print(f"Coordenadas guardadas correctamente")
+
+        return None
+    except Exception as e:
+        print(f"Error al procesar la imagen: {str(e)}")
+        return None
+
+# Función para procesar y guardar la imagen automáticamente en formato JPG
+def process_and_save_image2(image, coordinates_file_path="/tmp/coordinates2.txt"):
+    jpg_path = "/tmp/img_fragmento2.jpg"
+
+    try:
+        if image.format != "JPEG":
+            image = image.convert("RGB")
+        image.save(jpg_path, "JPEG", quality=100)
+        if os.path.exists(jpg_path):
+            print(f"Imagen guardada correctamente")
+
+            # Obtener las dimensiones de la imagen
+            width, height = image.size
+
+            # Guardar las coordenadas en un archivo de texto
+            with open(coordinates_file_path, "w") as file:
+                file.write(f"X: {width}\n")
+                file.write(f"Y: {height}\n")
+
+            print(f"Coordenadas guardadas correctamente")
+    
+    except Exception as e:
+        print(f"Error al procesar la imagen: {str(e)}")
+
+
+
+# Función para obtener el último frame de un video
+def get_last_frame(video_path):
+    try:
+        cap = cv2.VideoCapture(video_path)
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_count - 1)
+        ret, frame = cap.read()
+        cap.release()
+
+        if ret:
+            return Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        else:
+            print(f"Error al leer el último frame del video: {video_path}")
+            return None
+    except Exception as e:
+        print(f"Excepción al obtener el último frame: {str(e)}")
+        return None
+
+
+# Función para ejecutar los comandos de guardado
+def run_save_commands():
+    try:
+        print("Rendering video...")
+        commands = [
+            "python /content/Vidu_Studio/utils/fragment.py",
+            "python /content/Vidu_Studio/utils/union.py"
+        ]
+        output = ""
+        for command in commands:
+            result = subprocess.run(command, shell=True, capture_output=True, text=True)
+            output += f"Exit:\n{result.stdout}\n"
+            print(result.stdout)
+        video_path = "/content/Vidu_Studio/video.mp4"
+        return output, video_path
+    except Exception as e:
+        return f"Excepción al guardar: {str(e)}", None
+
+# Función para mostrar o ocultar el segundo cuadro de imagen
+def activar_end_frame(activar):
+    return gr.update(visible=activar)
+    
+# Definir la interfaz
+with gr.Blocks() as demo:
+    # Agregar un título en grande al inicio de la interfaz
+    gr.HTML(f"<h1 style='text-align: center; font-size: 3em;'>VIDU STUDIO 3.0 - AUTOMATIC</p>Created by:<a href='https://www.youtube.com/@IA.Sistema.de.Interes' target='_blank'>IA(Sistema de Interés)</a></p>")
+    with gr.Tabs():
+        # Primera pestaña: Image to Video
+        with gr.Tab("Image to Video"):
+            with gr.Row():
+                with gr.Column():
+                    add_end_frame = gr.Checkbox(label="Add End Frame", value=False)
+
+                    # Fila para mostrar ambas imágenes cuando se activa
+                    with gr.Row():
+                         # Imagen de inicio (carga de archivo)
+                        img1 = gr.Image(type="pil", label="Drag image here or select image", interactive=True,
+                    elem_id="img1", width=200, height=200)  # Ajustar tamaño de la imagen
+
+                        # Imagen de fin (se oculta inicialmente)
+                        img2 = gr.Image(type="pil", label="Upload the last frame image", interactive=True,
+                    elem_id="img2", visible=False, width=200, height=200)  # Ajustar tamaño de la imagen
+
+                    description_input = gr.Textbox(label="Prompt",
+                                                   placeholder="Aquí va una caja de texto editable para el prompt",
+                                                   elem_id="description_input")
+                    enhance_checkbox = gr.Checkbox(label="Enhance prompt", value=False, elem_id="enhance_checkbox")
+                    model_dropdown = gr.Dropdown(
+                        choices=["vidu-1", "vidu-high-performance"],
+                        label="Model",
+                        value="vidu-1",
+                        elem_id="model_dropdown"
+                    )
+                    upscale_checkbox = gr.Checkbox(label="Upscale", value=False, elem_id="upscale_checkbox")
+                    create_button = gr.Button("Create", elem_id="create_button")
+                    extend_button = gr.Button("Extend", elem_id="extend_button")
+                    recreate_button = gr.Button("Re-create", elem_id="recreate_button")  # Nuevo botón "Re-create"
+                    save_button = gr.Button("Save", elem_id="save_button") # Botón de guardado
+
+                with gr.Column():
+                    video_output = gr.Video(label="Video Output Image to Video", height=400, elem_id="video_output_image_to_video")
+                    output_textbox = gr.Textbox(label="Output", interactive=False, elem_id="output_textbox") # Cambia el nombre del textbox
+
+
+            # Lógica para mostrar el segundo cuadro de imagen al activar el checkbox
+            add_end_frame.change(activar_end_frame, add_end_frame, img2)
+
+            # Procesar la imagen automáticamente cuando se carga
+            img1.change(
+                fn=process_and_save_image1,
+                inputs=img1,
+                outputs=[]
+            )
+
+            img2.change(
+                fn=process_and_save_image2,
+                inputs=img2,
+                outputs=[]
+            )
+
+            # Botón "Create" y su salida
+            create_button.click(
+                fn=lambda desc, enhance, model, upscale, img, add_end: run_commands_dual(desc, "16:9", enhance, model, "general", upscale, task_type="headtailimg2video", img=img, add_end_frame=add_end),
+                inputs=[description_input, enhance_checkbox, model_dropdown, upscale_checkbox, img1, add_end_frame],  # Añade el Checkbox aquí
+                outputs=[output_textbox, video_output]  # Asegúrate de tener definidos estos componentes de salida
+            ) 
+
+            # Botón "Extend" y su salida
+            extend_button.click(
+                fn=lambda desc, enhance, model, upscale, img: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="extend", img=img, is_extend=True), # Agrega img como argumento
+                inputs=[description_input, enhance_checkbox, model_dropdown, upscale_checkbox, img1], # Agrega image_input a la lista de inputs
+                outputs=[output_textbox, video_output]
+            )
+
+            # Botón "Re-create" y su salida
+            recreate_button.click(
+                fn=lambda desc, enhance, model, upscale, img: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="image_to_video", img=img, is_recreate=True), # Agrega img como argumento
+                inputs=[description_input, enhance_checkbox, model_dropdown, upscale_checkbox, img1], # Agrega image_input a la lista de inputs
+                outputs=[output_textbox, video_output]
+            )
+
+            # Botón "Save" y su salida
+            save_button.click(
+                fn=run_save_commands,
+                inputs=[],
+                outputs=[output_textbox, video_output]
+            )
+
+        # Segunda pestaña: Reference to Video
+        with gr.Tab("Reference to Video"):
+            with gr.Row():
+                with gr.Column():
+                    image_input2 = gr.Image(type="pil", label="Drag image here or select image", interactive=True,
+                                            elem_id="image_input2")
+                    description_input2 = gr.Textbox(label="Prompt",
+                                                    placeholder="Enter text to begin creating a video that aligns with the subject of the image",
+                                                    elem_id="description_input2")
+                    enhance_checkbox2 = gr.Checkbox(label="Enhance prompt", value=False, elem_id="enhance_checkbox2")
+                    model_dropdown2 = gr.Dropdown(
+                        choices=["vidu-1", "vidu-high-performance"],
+                        label="Model",
+                        value="vidu-1",
+                        elem_id="model_dropdown2"
+                    )
+                    upscale_checkbox2 = gr.Checkbox(label="Upscale", value=False, elem_id="upscale_checkbox2")
+                    create_button2 = gr.Button("Create", elem_id="create_button2")
+                    extend_button2 = gr.Button("Extend", elem_id="extend_button2")
+                    recreate_button2 = gr.Button("Re-create", elem_id="recreate_button2")  # Nuevo botón "Re-create"
+                    save_button2 = gr.Button("Save", elem_id="save_button2") # Botón de guardado
+
+                with gr.Column():
+                    video_output2 = gr.Video(label="Video Output Reference to Video", height=400, elem_id="video_output_reference_to_video")
+                    output_textbox2 = gr.Textbox(label="Output", interactive=False, elem_id="output_textbox2") # Cambia el nombre del textbox
+
+            # Procesar la imagen automáticamente cuando se carga
+            image_input2.change(
+                fn=process_and_save_image,
+                inputs=image_input2,
+                outputs=[]
+            )
+
+            # Botón "Create" y su salida
+            create_button2.click(
+                fn=lambda desc, enhance, model, upscale, img: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="reference_to_video", img=img),
+                inputs=[description_input2, enhance_checkbox2, model_dropdown2, upscale_checkbox2, image_input2],
+                outputs=[output_textbox2, video_output2]
+            )
+
+            # Botón "Extend" y su salida
+            extend_button2.click(
+                fn=lambda desc, enhance, model, upscale, img: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="extend", img=img, is_extend=True),
+                inputs=[description_input2, enhance_checkbox2, model_dropdown2, upscale_checkbox2, image_input2],
+                outputs=[output_textbox2, video_output2]
+            )
+
+            # Botón "Re-create" y su salida
+            recreate_button2.click(
+                fn=lambda desc, enhance, model, upscale, img: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="reference_to_video", img=img, is_recreate=True),
+                inputs=[description_input2, enhance_checkbox2, model_dropdown2, upscale_checkbox2, image_input2],
+                outputs=[output_textbox2, video_output2]
+            )
+
+            # Botón "Save" y su salida
+            save_button2.click(
+                fn=run_save_commands,
+                inputs=[],
+                outputs=[output_textbox2, video_output2]
+            )
+
+        # Tercera pestaña: Text to Video
+        with gr.Tab("Text to Video"):
+            with gr.Row():
+                with gr.Column():
+                    description_input3 = gr.Textbox(label="Prompt",
+                                                    placeholder="Enter text to begin creating a video",
+                                                    elem_id="description_input3")
+                    aspect_ratio_dropdown = gr.Dropdown(
+                        choices=["16:9", "9:16", "4:3", "1:1"],
+                        label="Aspect Ratio",
+                        value="16:9",
+                        elem_id="aspect_ratio_dropdown"
+                    )
+                    enhance_checkbox3 = gr.Checkbox(label="Enhance prompt", value=False, elem_id="enhance_checkbox3")
+                    model_dropdown3 = gr.Dropdown(
+                        choices=["vidu-1", "vidu-high-performance"],
+                        label="Model",
+                        value="vidu-1",
+                        elem_id="model_dropdown3"
+                    )
+                    style_dropdown3 = gr.Dropdown(
+                        choices=["general", "anime"],
+                        label="Style",
+                        value="general",
+                        elem_id="style_dropdown3"
+                    )
+                    upscale_checkbox3 = gr.Checkbox(label="Upscale", value=False, elem_id="upscale_checkbox3")
+                    create_button3 = gr.Button("Create", elem_id="create_button3")
+                    extend_button3 = gr.Button("Extend", elem_id="extend_button3")
+                    recreate_button3 = gr.Button("Re-create", elem_id="recreate_button3")  # Nuevo botón "Re-create"
+                    save_button3 = gr.Button("Save", elem_id="save_button3") # Botón de guardado
+
+                with gr.Column():
+                    video_output3 = gr.Video(label="Video Output Text to Video", height=400, elem_id="video_output_text_to_video")
+                    output_textbox3 = gr.Textbox(label="Output", interactive=False, elem_id="output_textbox3") # Cambia el nombre del textbox
+
+            # Botón "Create" y su salida
+            create_button3.click(
+                fn=lambda desc, ratio, enhance, model, style, upscale: run_commands(desc, ratio, enhance, model, style,
+                                                                                     upscale, task_type="text_to_video"),
+                inputs=[description_input3, aspect_ratio_dropdown, enhance_checkbox3, model_dropdown3, style_dropdown3,
+                        upscale_checkbox3],
+                outputs=[output_textbox3, video_output3]
+            )
+
+            # Botón "Extend" y su salida
+            extend_button3.click(
+                fn=lambda desc, enhance, model, upscale: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="extend", is_extend=True), # "general" como argumento
+                inputs=[description_input3, enhance_checkbox3, model_dropdown3, upscale_checkbox3], # Eliminado "general"
+                outputs=[output_textbox3, video_output3]
+            )
+
+            # Botón "Re-create" y su salida
+            recreate_button3.click(
+                fn=lambda desc, ratio, enhance, model, style, upscale: run_commands(desc, ratio, enhance, model, style,
+                                                                                     upscale, task_type="text_to_video", is_recreate=True),
+                inputs=[description_input3, aspect_ratio_dropdown, enhance_checkbox3, model_dropdown3, style_dropdown3,
+                        upscale_checkbox3],
+                outputs=[output_textbox3, video_output3]
+            )
+
+            # Botón "Save" y su salida
+            save_button3.click(
+                fn=run_save_commands,
+                inputs=[],
+                outputs=[output_textbox3, video_output3]
+            )
+
+        # Cuarta pestaña: Video to Video
+        with gr.Tab("Video to Video"):
+            with gr.Row():
+                with gr.Column():
+                    video_input4 = gr.Video(label="Input Video", height=400, interactive=True)  # Agregar entrada de video
+                    description_input4 = gr.Textbox(label="Prompt",
+                                                    placeholder="Enter text to begin creating a video",
+                                                    elem_id="description_input4")
+                    enhance_checkbox4 = gr.Checkbox(label="Enhance prompt", value=False, elem_id="enhance_checkbox4")
+                    model_dropdown4 = gr.Dropdown(
+                        choices=["vidu-1", "vidu-high-performance"],
+                        label="Model",
+                        value="vidu-1",
+                        elem_id="model_dropdown4"
+                    )
+                    upscale_checkbox4 = gr.Checkbox(label="Upscale", value=False, elem_id="upscale_checkbox4")
+                    create_button4 = gr.Button("Create", elem_id="create_button4")
+                    extend_button4 = gr.Button("Extend", elem_id="extend_button4")
+                    recreate_button4 = gr.Button("Re-create", elem_id="recreate_button4")  # Nuevo botón "Re-create"
+                    save_button4 = gr.Button("Save", elem_id="save_button4") # Botón de guardado
+
+                with gr.Column():
+                    video_output4 = gr.Video(label="Video Output Video to Video", height=400, elem_id="video_output_video_to_video")
+                    output_textbox4 = gr.Textbox(label="Output", interactive=False, elem_id="output_textbox4") # Cambia el nombre del textbox
+
+            # Guardar el video cargado en /content/Vidu_Studio/video.mp4
+            def save_uploaded_video(video):
+                if video is not None:
+                    video_path = video
+                    result = subprocess.run(f"cp '{video_path}' /content/Vidu_Studio/videotovideo.mp4", shell=True)
+                    print(f"Video guardado en /content/Vidu_Studio/videotovideo.mp4")
+                    print(result.stdout)
+
+            # Ejecutar save_uploaded_video cuando se carga un video
+            video_input4.upload(
+                fn=save_uploaded_video,
+                inputs=video_input4,
+                outputs=None
+            )
+
+            # Botón "Create" y su salida
+            create_button4.click(
+                fn=lambda desc, enhance, model, upscale: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="video_to_video"), # "general" como argumento
+                inputs=[description_input4, enhance_checkbox4, model_dropdown4, upscale_checkbox4], # Eliminado "general"
+                outputs=[output_textbox4, video_output4]
+            )
+
+            # Botón "Extend" y su salida
+            extend_button4.click(
+                fn=lambda desc, enhance, model, upscale: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="extend", is_extend=True), # "general" como argumento
+                inputs=[description_input4, enhance_checkbox4, model_dropdown4, upscale_checkbox4], # Eliminado "general"
+                outputs=[output_textbox4, video_output4]
+            )
+
+            # Botón "Re-create" y su salida
+            recreate_button4.click(
+                fn=lambda desc, enhance, model, upscale: run_commands(desc, "16:9", enhance, model, "general", upscale, task_type="video_to_video", is_recreate=True), # "general" como argumento
+                inputs=[description_input4, enhance_checkbox4, model_dropdown4, upscale_checkbox4], # Eliminado "general"
+                outputs=[output_textbox4, video_output4]
+            )
+
+            # Botón "Save" y su salida
+            save_button4.click(
+                fn=run_save_commands,
+                inputs=[],
+                outputs=[output_textbox4, video_output4]
+            )
+
+# Ejecutar la interfaz
+demo.launch(inline=False, debug=True, share=True)

Vidu/create_task.py

@@ -0,0 +1,106 @@
+import requests
+import uuid
+import json
+import argparse  # Para manejar los argumentos de la línea de comandos
+
+def create_task(promptx, content_id, jwt_token, enhance, model):
+    url = "https://api.vidu.studio/vidu/v1/tasks"
+
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "X-Request-Id": str(uuid.uuid4()),
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+
+    payload = {
+        "input": {
+            "prompts": [
+                {"type": "text", "content": f"{promptx}"},
+                {"type": "image", "content": f"ssupload:?id={content_id}", "src_img": f"ssupload:?id={content_id}"}
+            ],
+            "enhance": enhance
+        },
+        "type": "img2video",
+        "settings": {
+            "duration": 4,
+            "model": model
+        }
+    }
+
+    response = requests.post(url, headers=headers, json=payload)
+    response_json = response.json()
+    task_id = response_json.get('id', 'ID no encontrado')
+
+    return task_id
+
+def read_file_info(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            if len(lines) >= 1:
+                file_id = lines[0].strip().split(': ')[1]
+                return file_id
+            else:
+                print("File does not contain enough lines.")
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_jwt_token(file_path):
+    try:
+        with open(file_path, "r") as file:
+            token = file.readline().strip()
+            return token
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def save_task_id(file_path, task_id):
+    try:
+        with open(file_path, "w") as file:
+            file.write(f"task_id: {task_id}")
+    except IOError as e:
+        print(f"Error writing file: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description='Script para crear una tarea con un prompt dado.')
+    parser.add_argument('--prompt', type=str, required=True, help='Prompt a utilizar')
+    parser.add_argument('--enhance', type=bool, default=True, help='Habilitar mejora (True o False)')
+    parser.add_argument('--model', type=str, required=True, help='Modelo a usar (vidu-1 o vidu-high-performance)')
+    
+    args = parser.parse_args()
+
+    file_info_path = "/tmp/file_info.txt"  # Ruta al archivo que contiene file_id
+    jwt_token_path = "/tmp/jwt_token.txt"   # Ruta al archivo que contiene el jwt_token
+    task_id_path = "/tmp/task_id.txt"       # Ruta al archivo donde se guardará el task_id
+
+    file_id = read_file_info(file_info_path)
+    jwt_token = read_jwt_token(jwt_token_path)
+
+    if file_id and jwt_token:
+        try:
+            task_id = create_task(args.prompt, file_id, jwt_token, enhance=args.enhance, model=args.model)
+            #print(f"El ID de la tarea es: {task_id}")
+            save_task_id(task_id_path, task_id)
+        except Exception as e:
+            print(e)
+
+if __name__ == "__main__":
+    main()
+

Vidu/create_text_to_video.py

@@ -0,0 +1,84 @@
+import requests
+import argparse
+import uuid
+
+def create_video_task(jwt_token, prompt, aspect_ratio, enhance, model, style):
+    url = "https://api.vidu.studio/vidu/v1/tasks"
+    
+    headers = {
+        "Host": "api.vidu.studio",
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "X-Request-Id": str(uuid.uuid4()),
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+    
+    payload = {
+        "input": {
+            "prompts": [
+                {
+                    "type": "text",
+                    "content": prompt,
+                    "enhance": enhance
+                }
+            ]
+        },
+        "type": "text2video",
+        "settings": {
+            "style": style,
+            "aspect_ratio": aspect_ratio,  # Relación de aspecto editable
+            "duration": 4,
+            "model": model #"vidu-1"
+        }
+    }
+
+    response = requests.post(url, headers=headers, json=payload)
+    response_json = response.json()
+    task_id = response_json.get('id', 'ID no encontrado')
+
+    return task_id
+
+def save_task_id(file_path, task_id):
+    try:
+        with open(file_path, "w") as file:
+            file.write(f"task_id: {task_id}")
+    except IOError as e:
+        print(f"Error writing file: {e}")
+
+def main():
+    # Configurar el análisis de argumentos
+    parser = argparse.ArgumentParser(description="Create a video task using the Vidu API.")
+    parser.add_argument('--prompt', type=str, required=True, help="The text prompt to generate the video.")
+    parser.add_argument('--aspect_ratio', type=str, default="16:9", help="The aspect ratio of the video (e.g., 16:9, 1:1, 4:3).")
+    parser.add_argument('--enhance', type=bool, default=True, help='Habilitar mejora (True o False)')
+    parser.add_argument('--model', type=str, required=True, help='vidu-1')
+    parser.add_argument('--style', type=str, required=True, help='general')
+
+    args = parser.parse_args()
+
+    # Leer el JWT token desde el archivo
+    with open('/tmp/jwt_token.txt', 'r') as file:
+        jwt_token = file.read().strip()
+
+    # Llamar a la función con el argumento del prompt y el aspect_ratio
+    task_id = create_video_task(jwt_token, args.prompt, args.aspect_ratio, enhance=args.enhance, model=args.model, style=args.style)
+    #print(f"El ID de la tarea es: {task_id}")
+
+    # Guardar el task_id en un archivo
+    save_task_id('/tmp/task_id.txt', task_id)
+
+if __name__ == "__main__":
+    main()
+

Vidu/create_video_reference.py

@@ -0,0 +1,135 @@
+import requests
+import json
+import argparse
+import uuid
+
+def create_video_reference(jwt_token, prompt_text, image_id, enhance, x, y, model):
+    url = "https://api.vidu.studio/vidu/v1/tasks"
+    
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "X-Request-Id": str(uuid.uuid4()),
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+
+    payload = {
+        "input": {
+            "prompts": [
+                {
+                    "type": "text",
+                    "content": (f"{prompt_text}")
+                },
+                {
+                    "type": "image",
+                    "content": f"ssupload:?id={image_id}",
+                    "src_img": f"ssupload:?id={image_id}",
+                    "selected_region": {
+                        "top_left": {"x": 0, "y": 0},
+                        "bottom_right": {"x": x, "y": y}
+                    }
+                }
+            ],
+            "enhance": enhance
+        },
+        "type": "character2video",
+        "settings": {
+            "duration": 4,
+            "model": f"{model}"
+        }
+    }
+
+    data = json.dumps(payload)
+    response = requests.post(url, headers=headers, data=data)
+    response_json = response.json()
+    task_id = response_json.get('id', 'ID no encontrado')
+
+    return task_id
+
+def read_file_info(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            if len(lines) >= 1:
+                file_id = lines[0].strip().split(': ')[1]
+                return file_id
+            else:
+                print("File does not contain enough lines.")
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_jwt_token(file_path):
+    try:
+        with open(file_path, "r") as file:
+            token = file.readline().strip()
+            return token
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_coordinates(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            x = y = 512  # Default values
+            for line in lines:
+                if line.startswith("X: "):
+                    x = int(line.strip().split(": ")[1])
+                elif line.startswith("Y: "):
+                    y = int(line.strip().split(": ")[1])
+            return x, y
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def save_task_id(file_path, task_id):
+    try:
+        with open(file_path, "w") as file:
+            file.write(f"task_id: {task_id}")
+    except IOError as e:
+        print(f"Error writing file: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description='Script para crear una tarea con un prompt dado.')
+    parser.add_argument('--prompt', type=str, required=True, help='Prompt a utilizar')
+    parser.add_argument('--enhance', type=bool, default=True, help='Habilitar mejora (True o False)')
+    parser.add_argument('--model', type=str, required=True, help='vidu-1')
+    
+    args = parser.parse_args()
+
+    file_info_path = "/tmp/file_info.txt"  # Ruta al archivo que contiene file_id
+    jwt_token_path = "/tmp/jwt_token.txt"  # Ruta al archivo que contiene el jwt_token
+    task_id_path = "/tmp/task_id.txt"      # Ruta al archivo donde se guardará el task_id
+    coordinates_path = "/tmp/coordinates.txt"  # Ruta al archivo que contiene las coordenadas
+
+    file_id = read_file_info(file_info_path)
+    jwt_token = read_jwt_token(jwt_token_path)
+    x, y = read_coordinates(coordinates_path)
+
+    if file_id and jwt_token:
+        try:
+            task_id = create_video_reference(jwt_token, args.prompt, file_id, enhance=args.enhance, x=x, y=y, model=args.model)
+            #print(f"El ID de la tarea es: {task_id}")
+            save_task_id(task_id_path, task_id)
+        except Exception as e:
+            print(e)
+
+if __name__ == "__main__":
+    main()

Vidu/headtailimg2video.py

@@ -0,0 +1,146 @@
+import requests
+import json
+import argparse
+import uuid
+
+def create_video_reference(jwt_token, prompt_text, image_id, image_id2, enhance, x, y, x2, y2, model):
+    
+    url = "https://api.vidu.studio/vidu/v1/tasks"
+    
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "X-Request-ID": str(uuid.uuid4()),
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    payload = {
+        "input": {
+            "prompts": [
+                {"type": "text", "content": f"{prompt_text}"},
+                {
+                    "type": "image", 
+                    "content": f"ssupload:?id={image_id}",
+                    "src_img": f"ssupload:?id={image_id}",
+                    "selected_region": {
+                        "top_left": {"x": 0, "y": 0},
+                        "bottom_right": {"x": x, "y": y}
+                    }
+                },
+                {
+                    "type": "image", 
+                    "content": f"ssupload:?id={image_id2}",
+                    "src_img": f"ssupload:?id={image_id2}",
+                    "selected_region": {
+                        "top_left": {"x": 0, "y": 0},
+                        "bottom_right": {"x": x2, "y": y2}
+                    }
+                }
+            ],
+            "enhance": True
+        },
+        "type": "headtailimg2video",
+        "settings": {
+            "duration": 4,
+            "model": "vidu-high-performance"
+        }
+    }
+
+
+    data = json.dumps(payload)
+    response = requests.post(url, headers=headers, data=data)
+    response_json = response.json()
+    task_id = response_json.get('id', 'ID no encontrado')
+
+    return task_id
+
+def read_file_info(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            if len(lines) >= 1:
+                file_id = lines[0].strip().split(': ')[1]
+                return file_id
+            else:
+                print("File does not contain enough lines.")
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_jwt_token(file_path):
+    try:
+        with open(file_path, "r") as file:
+            token = file.readline().strip()
+            return token
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_coordinates(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            x = y = 512  # Default values
+            for line in lines:
+                if line.startswith("X: "):
+                    x = int(line.strip().split(": ")[1])
+                elif line.startswith("Y: "):
+                    y = int(line.strip().split(": ")[1])
+            return x, y
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def save_task_id(file_path, task_id):
+    try:
+        with open(file_path, "w") as file:
+            file.write(f"task_id: {task_id}")
+    except IOError as e:
+        print(f"Error writing file: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description='Script para crear una tarea con un prompt dado.')
+    parser.add_argument('--prompt', type=str, required=True, help='Prompt a utilizar')
+    parser.add_argument('--enhance', type=bool, default=True, help='Habilitar mejora (True o False)')
+    parser.add_argument('--model', type=str, required=True, help='vidu-1')
+    
+    args = parser.parse_args()
+
+    file_info_path = "/tmp/file_info.txt"  # Ruta al archivo que contiene file_id
+    file_info_path2 = "/tmp/file_info2.txt"  # Ruta al archivo que contiene file_id
+    jwt_token_path = "/tmp/jwt_token.txt"  # Ruta al archivo que contiene el jwt_token
+    task_id_path = "/tmp/task_id.txt"      # Ruta al archivo donde se guardará el task_id
+    coordinates_path = "/tmp/coordinates.txt"  # Ruta al archivo que contiene las coordenadas
+    coordinates_path2 = "/tmp/coordinates2.txt"  # Ruta al archivo que contiene las coordenadas
+
+    file_id = read_file_info(file_info_path)
+    file_id2 = read_file_info(file_info_path2)
+    jwt_token = read_jwt_token(jwt_token_path)
+    x, y = read_coordinates(coordinates_path)
+    x2, y2 = read_coordinates(coordinates_path2)
+
+    if file_id and jwt_token:
+        try:
+            task_id = create_video_reference(jwt_token, args.prompt, file_id, file_id2, enhance=args.enhance, x=x, y=y, x2=x2, y2=y2, model=args.model)
+            #print(f"El ID de la tarea es: {task_id}")
+            save_task_id(task_id_path, task_id)
+        except Exception as e:
+            print(e)
+
+if __name__ == "__main__":
+    main()

Vidu/main.py

@@ -0,0 +1,69 @@
+import time
+from utils.utils import generar_contrasena, generar_nombre_completo, enviar_formulario, obtener_sitio_web_aleatorio
+from utils.auth import send_auth_code, login_to_vidu
+from utils.email_utils import get_verification_code, delete_temp_mail
+
+# Ejemplo de uso
+password_segura = generar_contrasena()
+url = 'https://email-fake.com/'
+
+# Supongamos que el formulario en el sitio web tiene un campo llamado 'campo_correo'
+datos = {'campo_correo': 'ejemplo@dominio.com'}
+
+# Enviar la solicitud POST al formulario
+response = enviar_formulario(url, datos)
+
+# Obtener un sitio web aleatorio de los dominios extraídos
+sitio_domain = obtener_sitio_web_aleatorio(response.text)
+
+# Generar y mostrar un nombre completo
+nombre_completo = generar_nombre_completo()
+
+#print(f'Email: {nombre_completo}@{sitio_domain}')
+#print(f'Password: {password_segura}')
+
+time.sleep(3)
+
+email_reg = f"{nombre_completo}@{sitio_domain}"
+# Enviar código de autenticación al correo
+send_auth_code(email_reg)
+print("60 seconds")
+time.sleep(1)
+
+# Intentar obtener el código de verificación durante 60 segundos (6 intentos con una pausa de 10 segundos)
+verification_code = None
+identifier = None
+attempts = 6  # 6 intentos para un minuto (cada 10 segundos)
+for attempt in range(attempts):
+    print(f"Attempt {attempt + 1} from {attempts}...")
+    
+    # Obtener el código de verificación y el identificador
+    verification_code, identifier = get_verification_code(nombre_completo, sitio_domain)
+
+    if verification_code and identifier:
+        print(f"Código de verificación encontrado: {verification_code}")
+        break  # Salir del bucle si se encuentra el código
+
+    time.sleep(10)  # Esperar 10 segundos antes de intentar nuevamente
+
+if verification_code and identifier:
+    print(f"Código de verificación: {verification_code}")
+    print(f"Identificador: {identifier}")
+    time.sleep(3)
+    print("Login...")
+    
+    # Realizar el login y obtener el JWT Token
+    response, jwt_token = login_to_vidu(email_reg, verification_code)
+
+    if jwt_token:
+        print("Login exitoso. Token obtenido.")
+        # Guardar el JWT Token en un archivo
+        with open('/tmp/jwt_token.txt', 'w') as f:
+            f.write(jwt_token)
+else:
+    print("No se pudieron encontrar los datos necesarios.")
+
+time.sleep(3)
+
+# Eliminar el correo temporal
+delete_temp_mail(nombre_completo, sitio_domain, identifier)

Vidu/resident.py

@@ -0,0 +1,25 @@
+import base64
+
+class A:
+    def __init__(self, shift=5):  # Shift está fijo en 5
+        self.shift = shift
+        self.chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+    def c(self, data):
+        """
+        Codifica los datos usando Base64 y altera los caracteres.
+        """
+        encoded = base64.b64encode(data.encode()).decode()
+        return ''.join(self.chars[(self.chars.index(char) + self.shift) % len(self.chars)]
+                       if char in self.chars else char for char in encoded)
+
+    def d(self, data):
+        """
+        Decodifica los datos modificados y los convierte nuevamente en Base64.
+        """
+        decoded = ''.join(self.chars[(self.chars.index(char) - self.shift) % len(self.chars)]
+                          if char in self.chars else char for char in data)
+        return base64.b64decode(decoded).decode()
+
+# Instancia fija con shift=5
+resident = A(shift=5)

Vidu/upload/file_uploader.py

@@ -0,0 +1,106 @@
+import argparse
+import requests
+import uuid
+import subprocess
+
+# Función para ejecutar el script con subprocess
+def run_file_uploader(file_info_name, image_name):
+    print("ok")
+    try:
+        # Ejecuta el comando para ejecutar el script con el argumento file_info
+        result = subprocess.run(["python", "/content/Vidu_Studio/upload/file_uploader_with_etag.py", "--file_info", file_info_name,  "--image",  image_name], 
+                                capture_output=True, text=True)
+        print(result.stderr)
+        # Devuelve la salida del comando
+        if result.returncode == 0:
+            return f"Script ejecutado correctamente: {result.stdout}"
+        else:
+            return f"Error en la ejecución: {result.stderr}"
+
+    except Exception as e:
+        return f"Error al intentar ejecutar el script: {str(e)}"
+
+def upload_file_to_vidu(jwt_token):
+    url = "https://api.vidu.studio/tools/v1/files/uploads"
+
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "X-Request-Id": str(uuid.uuid4()),
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+    }
+
+    payload = {
+        "scene": "vidu"
+    }
+
+    try:
+        # Enviar la solicitud POST
+        response = requests.post(url, headers=headers, json=payload)
+
+        # Procesar la respuesta
+        response_json = response.json()
+        file_id = response_json.get("id")
+        put_url = response_json.get("put_url")
+
+        # Mostrar los valores extraídos
+        print(f"ID: {file_id}")
+        #print(f"PUT URL: {put_url}")
+
+        return file_id, put_url
+
+    except requests.exceptions.RequestException as e:
+        print(f"Request failed: {e}")
+    except ValueError as e:
+        print(f"Error decoding JSON: {e}")
+
+def save_to_txt(file_id, put_url, filename):
+    with open(filename, "w") as file:
+        file.write(f"file_id: {file_id}\n")
+        file.write(f"put_url: {put_url}\n")
+    #print(f"Data saved to {filename}")
+
+def read_jwt_from_file(file_path):
+    try:
+        with open(file_path, "r") as file:
+            jwt_token = file.read().strip()
+        return jwt_token
+    except FileNotFoundError:
+        print(f"File not found: jwtToken")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def main():
+    # Configurar argparse dentro de la función main
+    parser = argparse.ArgumentParser(description="Subir archivos a Vidu Studio")
+    parser.add_argument("--file_info", type=str, required=True, help="Nombre del archivo de información a guardar")
+    parser.add_argument("--image", type=str, required=True, help="Nombre base del archivo de imagen (sin extensión)")
+    
+    # Parsear los argumentos
+    args = parser.parse_args()
+    file_info_name = args.file_info
+    image_name = args.image
+    
+    jwt_file_path = "/tmp/jwt_token.txt"  # Ruta al archivo que contiene el JWT
+    jwt_token = read_jwt_from_file(jwt_file_path)
+    
+    if jwt_token:
+        file_id, put_url = upload_file_to_vidu(jwt_token)
+        if file_id and put_url:
+            save_to_txt(file_id, put_url, filename=f"/tmp/{file_info_name}.txt")
+    
+    run_file_uploader(file_info_name, image_name)
+
+if __name__ == "__main__":
+    main()

Vidu/upload/file_uploader_with_etag.py

@@ -0,0 +1,101 @@
+import argparse
+import requests
+import subprocess
+
+# Función para ejecutar el script con subprocess
+def run_finish_upload(file_info_name):
+    try:
+        # Ejecuta el comando para ejecutar el script con el argumento file_info
+        result = subprocess.run(["python", "/content/Vidu_Studio/upload/finish_upload.py", "--file_info", file_info_name], 
+                                capture_output=True, text=True)
+        
+        # Devuelve la salida del comando
+        if result.returncode == 0:
+            return f"Script ejecutado correctamente: {result.stdout}"
+        else:
+            return f"Error en la ejecución: {result.stderr}"
+
+    except Exception as e:
+        return f"Error al intentar ejecutar el script: {str(e)}"
+
+def upload_file_to_vidu(upload_url, file_path):
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Content-Type": "image/*",  # Asegúrate de que el tipo de contenido coincida con el archivo que estás subiendo
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Accept-Language": "es-ES,es;q=0.9",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    with open(file_path, 'rb') as file:
+        response = requests.put(upload_url, headers=headers, data=file)
+
+    # Verificando el estado de la respuesta
+    if response.status_code == 200:
+        # Capturando los encabezados de la respuesta
+        response_headers = response.headers
+        # Extrayendo el valor del encabezado ETag
+        etag = response_headers.get('ETag', 'Encabezado ETag no encontrado')
+        return etag.replace('"', '')
+    else:
+        raise Exception(f"Error al subir el archivo: {response.status_code}")
+
+def save_etag_to_txt(etag, filename="/tmp/etag_info.txt"):
+    with open(filename, "w") as file:
+        file.write(f"ETag: {etag}\n")
+    print(f"ETag saved to {etag}")
+
+def read_file_info(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            if len(lines) >= 2:
+                file_id = lines[0].strip().split(': ')[1]
+                put_url = lines[1].strip().split(': ')[1]
+                return file_id, put_url
+            else:
+                print("File does not contain enough lines.")
+    except FileNotFoundError:
+        print(f"File not found: file_info or Image")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def main():
+    print("uplaodr 2")
+    # Usamos argparse para obtener los nombres de los archivos
+    parser = argparse.ArgumentParser(description="Subir un archivo a Vidu Studio y obtener el ETag")
+    parser.add_argument("--file_info", type=str, required=True, help="Nombre base del archivo de información (sin extensión)")
+    parser.add_argument("--image", type=str, required=True, help="Nombre base del archivo de imagen (sin extensión)")
+
+    # Parsear los argumentos de la línea de comandos
+    args = parser.parse_args()
+
+    # Construir las rutas de archivo usando los nombres proporcionados
+    file_info_path = f"/tmp/{args.file_info}.txt"  # Ruta al archivo de información
+    image_path = f"/tmp/{args.image}.jpg"          # Ruta al archivo de imagen
+
+    # Leer file_info.txt
+    file_id, put_url = read_file_info(file_info_path)
+    
+    if put_url:
+        try:
+            # Subir el archivo y obtener el ETag
+            etag = upload_file_to_vidu(put_url, image_path)
+            # Guardar el ETag en un archivo
+            save_etag_to_txt(etag)
+        except Exception as e:
+            print(e)
+
+    run_finish_upload(args.file_info)
+
+if __name__ == "__main__":
+    main()

Vidu/upload/finish_upload.py

@@ -0,0 +1,95 @@
+import argparse
+import requests
+
+def finish_upload(upload_id, etag, jwt_token):
+    url = f"https://api.vidu.studio/tools/v1/files/uploads/{upload_id}/finish"
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"JWT={jwt_token}",
+        "Accept-Encoding": "gzip, deflate"
+    }
+    payload = {
+        "id": upload_id,
+        "etag": etag
+    }
+
+    response = requests.put(url, headers=headers, json=payload)
+    print(f"ETag: {etag}")
+
+    # Verificando el estado de la respuesta
+    return response.text
+
+def read_file_info(file_path):
+    try:
+        with open(file_path, "r") as file:
+            lines = file.readlines()
+            if len(lines) >= 2:
+                file_id = lines[0].strip().split(': ')[1]
+                put_url = lines[1].strip().split(': ')[1]
+                return file_id, put_url
+            else:
+                print("File does not contain enough lines.")
+    except FileNotFoundError:
+        print(f"File not found: file_info or etag_info")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_etag(file_path):
+    try:
+        with open(file_path, "r") as file:
+            line = file.readline().strip()
+            etag = line.split(': ')[1] if ': ' in line else None
+            return etag
+    except FileNotFoundError:
+        print(f"File not found: etag_info")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+def read_jwt_token(file_path):
+    try:
+        with open(file_path, "r") as file:
+            token = file.readline().strip()
+            return token
+    except FileNotFoundError:
+        print(f"File not found: jwtToken")
+    except IOError as e:
+        print(f"Error reading file: {e}")
+
+
+def main():
+    # Usamos argparse para permitir la personalización del nombre del archivo de información
+    parser = argparse.ArgumentParser(description="Finalizar la subida de archivos a Vidu Studio")
+    parser.add_argument("--file_info", type=str, required=True, help="Nombre base del archivo de información (sin extensión)")
+
+    args = parser.parse_args()
+
+    # Crear las rutas de archivo usando los nombres proporcionados
+    file_info_path = f"/tmp/{args.file_info}.txt"  # Ruta al archivo de información (editable)
+    etag_info_path = "/tmp/etag_info.txt"   # Ruta al archivo que contiene el etag
+    jwt_token_path = "/tmp/jwt_token.txt"   # Ruta al archivo que contiene el jwt_token
+
+    file_id, put_url = read_file_info(file_info_path)
+    etag = read_etag(etag_info_path)
+    jwt_token = read_jwt_token(jwt_token_path)
+
+    if file_id and etag and jwt_token:
+        try:
+            result = finish_upload(file_id, etag, jwt_token)
+            #print(result)  # Puedes descomentar si quieres ver la respuesta
+        except Exception as e:
+            print(e)
+
+if __name__ == "__main__":
+    main()

Vidu/utils/auth.py

@@ -0,0 +1,79 @@
+import requests
+import uuid
+
+def extract_jwt_cookie(cookies):
+    """Extrae el valor de la cookie JWT."""
+    jwt_token = cookies.get('JWT')
+    return jwt_token
+
+def login_to_vidu(correo, codes):
+    """Inicia sesión en Vidu y devuelve la respuesta y el token JWT."""
+    url = "https://api.vidu.studio/iam/v1/users/login"
+
+    headers = {
+        "Host": "api.vidu.studio",
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "Content-Type": "application/json",
+        "X-Request-Id": str(uuid.uuid4()),  # Genera un UUID aleatorio
+        "sec-ch-ua-platform": "Windows",
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": "sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22gae28_aV%22%3A%22%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKagN%3D%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%22%2C%22Cikbr%22%3A%22%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578971.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    payload = {
+        "id_type": "email",
+        "identity": correo,
+        "auth_type": "authcode",
+        "credential": codes
+    }
+
+    response = requests.post(url, headers=headers, json=payload)
+    jwt_token = extract_jwt_cookie(response.cookies)
+    return response.json(), jwt_token
+
+def send_auth_code(correo):
+    """Envía un código de autenticación al correo especificado."""
+    url = "https://api.vidu.studio/iam/v1/users/send-auth-code"
+    headers = {
+        "Host": "api.vidu.studio",
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "content-type": "application/json",
+        "X-Request-Id": str(uuid.uuid4()),  # Genera un UUID aleatorio
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22gae28_aV%22%3A%22%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKagN%3D%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%22%2C%22Cikbr%22%3A%22%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578971.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+    payload = {
+        "channel": "email",
+        "receiver": f"{correo}",
+        "purpose": "login",
+        "locale": "en"
+    }
+
+    response = requests.post(url, headers=headers, json=payload)
+
+    if response.status_code == 200:
+        print("Request successful")
+        
+    else:
+        print(f"Request failed with status code {response.status_code}")

Vidu/utils/delete_task.py

@@ -0,0 +1,81 @@
+import requests
+import re
+
+def read_task_id(file_path):
+    """
+    Leer el task_id desde un archivo, eliminando el texto extra y dejando solo el número.
+    """
+    try:
+        with open(file_path, "r") as file:
+            task_id_line = file.readline().strip()
+            # Usar una expresión regular para extraer solo el número del task_id
+            match = re.search(r'\d+', task_id_line)
+            if match:
+                return match.group(0)
+            else:
+                print("No se encontró un task_id válido.")
+                return None
+    except FileNotFoundError:
+        print(f"Archivo no encontrado: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error leyendo el archivo: {e}")
+        return None
+
+def read_jwt_token(file_path):
+    """
+    Leer el jwt_token desde un archivo.
+    """
+    try:
+        with open(file_path, "r") as file:
+            return file.readline().strip()
+    except FileNotFoundError:
+        print(f"Archivo no encontrado: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error leyendo el archivo: {e}")
+        return None
+
+def delete_task(task_id, jwt_token):
+    """
+    Eliminar la tarea usando el task_id y el jwt_token.
+    """
+    url = f"https://api.vidu.studio/vidu/v1/tasks/{task_id}"
+
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    # Realizar la solicitud DELETE
+    response = requests.delete(url, headers=headers)
+
+    if response.status_code == 200:
+        print(f"Tarea {task_id} eliminada exitosamente.")
+    else:
+        print(f"Error al eliminar la tarea {task_id}. Código de estado: {response.status_code}")
+
+if __name__ == "__main__":
+    task_id_path = "/tmp/task_id.txt"
+    jwt_token_path = "/tmp/jwt_token.txt"
+
+    # Leer task_id y jwt_token desde los archivos correspondientes
+    task_id = read_task_id(task_id_path)
+    jwt_token = read_jwt_token(jwt_token_path)
+
+    if task_id and jwt_token:
+        delete_task(task_id, jwt_token)
+    else:
+        print("Error: No se pudo leer el task_id o el jwt_token.")

Vidu/utils/delete_task_upscale.py

@@ -0,0 +1,81 @@
+import requests
+import re
+
+def read_task_id(file_path):
+    """
+    Leer el task_id desde un archivo, eliminando el texto extra y dejando solo el número.
+    """
+    try:
+        with open(file_path, "r") as file:
+            task_id_line = file.readline().strip()
+            # Usar una expresión regular para extraer solo el número del task_id
+            match = re.search(r'\d+', task_id_line)
+            if match:
+                return match.group(0)
+            else:
+                print("No se encontró un task_id válido.")
+                return None
+    except FileNotFoundError:
+        print(f"Archivo no encontrado: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error leyendo el archivo: {e}")
+        return None
+
+def read_jwt_token(file_path):
+    """
+    Leer el jwt_token desde un archivo.
+    """
+    try:
+        with open(file_path, "r") as file:
+            return file.readline().strip()
+    except FileNotFoundError:
+        print(f"Archivo no encontrado: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error leyendo el archivo: {e}")
+        return None
+
+def delete_task(task_id, jwt_token):
+    """
+    Eliminar la tarea usando el task_id y el jwt_token.
+    """
+    url = f"https://api.vidu.studio/vidu/v1/tasks/{task_id}"
+
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    # Realizar la solicitud DELETE
+    response = requests.delete(url, headers=headers)
+
+    if response.status_code == 200:
+        print(f"Tarea {task_id} eliminada exitosamente.")
+    else:
+        print(f"Error al eliminar la tarea {task_id}. Código de estado: {response.status_code}")
+
+if __name__ == "__main__":
+    task_id_path = "/tmp/task_id_upscale.txt"
+    jwt_token_path = "/tmp/jwt_token.txt"
+
+    # Leer task_id y jwt_token desde los archivos correspondientes
+    task_id = read_task_id(task_id_path)
+    jwt_token = read_jwt_token(jwt_token_path)
+
+    if task_id and jwt_token:
+        delete_task(task_id, jwt_token)
+    else:
+        print("Error: No se pudo leer el task_id o el jwt_token.")

Vidu/utils/email_utils.py

@@ -0,0 +1,78 @@
+import re
+import requests
+
+COMMON_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Accept-Language': 'es-ES,es;q=0.9',
+    'Accept-Encoding': 'gzip, deflate'
+}
+
+def delete_temp_mail(username_email, dominios_dropdown, extracted_string):
+    """Borra el correo temporal especificado."""
+    EMAIL_FAKE_URL = 'https://email-fake.com/'
+    url = f"{EMAIL_FAKE_URL}/del_mail.php"
+
+    headers = {
+        'Host': 'email-fake.com',
+        'Connection': 'keep-alive',
+        'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+        'Accept': '*/*',
+        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+        'X-Requested-With': 'XMLHttpRequest',
+        'sec-ch-ua-mobile': '?0',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'sec-ch-ua-platform': '"Windows"',
+        'Origin': 'https://email-fake.com',
+        'Sec-Fetch-Site': 'same-origin',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Dest': 'empty',
+        'Accept-Language': 'es-ES,es;q=0.9',
+        'Cookie': f'embx=%5B%22{username_email}%40{dominios_dropdown}%22%2C',
+    }
+
+    data = f'delll={extracted_string}'
+
+    response = requests.post(url, headers=headers, data=data)
+
+    if "Message deleted successfully" in response.text:
+        print("Temporary mail deleted...")
+        return True
+    else:
+        print("Error deleting temporary email...")
+        return False
+
+def get_verification_code(username_email, dominios_dropdown):
+    """Obtiene el código de verificación del correo y el identificador."""
+    EMAIL_FAKE_URL = 'https://email-fake.com/'
+    url = f"{EMAIL_FAKE_URL}/"
+
+    headers = {
+        'Host': 'email-fake.com',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1',
+        **COMMON_HEADERS,
+        'Sec-Fetch-Site': 'none',
+        'Sec-Fetch-Mode': 'navigate',
+        'Sec-Fetch-User': '?1',
+        'Sec-Fetch-Dest': 'document',
+        'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': 'Windows',
+        'Cookie': f'surl={dominios_dropdown}%2F{username_email}',
+    }
+
+    response = requests.get(url, headers=headers)
+
+    # Utiliza una expresión regular para encontrar el código de 6 dígitos
+    verification_code_match = re.search(r'<strong>(\d{6})</strong>', response.text)
+    
+    # Utiliza una expresión regular para encontrar el identificador largo
+    identifier_match = re.search(r'delll:\s*"([a-zA-Z0-9]+)"', response.text)
+
+    # Extrae y retorna los valores si fueron encontrados
+    if verification_code_match and identifier_match:
+        verification_code = verification_code_match.group(1)
+        identifier = identifier_match.group(1)
+        return verification_code, identifier
+    else:
+        return None, None

Vidu/utils/fragment.py

@@ -0,0 +1,101 @@
+import cv2
+import os
+import shutil
+import subprocess
+
+def extraer_ultimo_fotograma(video_path, output_image_path):
+    """
+    Extrae el último fotograma de un video y lo guarda como una imagen JPG con calidad 100%.
+    Luego copia el video a la carpeta '/content/video_output' con numeración secuencial.
+    
+    :param video_path: Ruta del archivo de video (ej. '/content/video.mp4')
+    :param output_image_path: Ruta donde se guardará el fotograma como imagen (ej. '/content/img_fragmento.jpg')
+    """
+    # Método 1: Usando OpenCV (si está disponible)
+    try:
+        # Capturamos el video
+        video = cv2.VideoCapture(video_path)
+
+        # Obtenemos el número total de fotogramas
+        total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        # Nos desplazamos al último fotograma
+        video.set(cv2.CAP_PROP_POS_FRAMES, total_frames - 1)
+
+        # Leemos el último fotograma
+        ret, frame = video.read()
+
+        # Si el fotograma fue leído correctamente, lo guardamos como imagen con calidad 100%
+        if ret:
+            # Guardamos la imagen con calidad 100%
+            cv2.imwrite(output_image_path, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
+            print(f'Último fotograma guardado con calidad 100% (OpenCV)')
+        else:
+            print('Error al leer el último fotograma (OpenCV)')
+
+        # Liberamos el objeto video
+        video.release()
+
+    except Exception as e:
+        print(f"Error al usar OpenCV: {e}")
+
+        # Método 2: Usando FFmpeg (si OpenCV falla)
+        # Obtiene la duración del video
+        duracion_cmd = [
+            "ffprobe",
+            "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            video_path
+        ]
+        duracion = float(subprocess.check_output(duracion_cmd))
+
+        # Calcula el tiempo para buscar cerca del final (0.1 segundos antes)
+        tiempo_busqueda = str(duracion - 0.1)
+
+        # Construye el comando FFmpeg para extraer el último fotograma
+        comando = [
+            "ffmpeg",
+            "-ss", tiempo_busqueda,  # Busca cerca del final
+            "-i", video_path,
+            "-vframes", "1",  # Extrae solo un fotograma
+            "-qscale:v", "2",  # Ajusta la calidad si es necesario
+            output_image_path
+        ]
+
+        # Ejecuta el comando FFmpeg
+        subprocess.run(comando)
+        print(f'Último fotograma guardado con calidad 100% (FFmpeg)')
+
+    # Crear la carpeta '/content/video_output' si no existe
+    output_folder = '/content/Vidu_Studio/video_output'
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+        print(f'Carpeta creada: {output_folder}')
+    
+    # Verificar la numeración de los archivos en la carpeta
+    existing_videos = sorted([f for f in os.listdir(output_folder) if f.endswith('.mp4')])
+    
+    if existing_videos:
+        # Obtener el último número de archivo y aumentar en 1
+        last_video = existing_videos[-1]
+        last_number = int(last_video.split('.')[0])  # Extraer número del formato '00001.mp4'
+        new_number = last_number + 1
+    else:
+        # Si no existen archivos, comenzar con '00001'
+        new_number = 1
+
+    # Formatear el nuevo nombre del archivo con ceros iniciales
+    new_video_name = f'{new_number:05}.mp4'
+    new_video_path = os.path.join(output_folder, new_video_name)
+
+    # Copiar el video original a la nueva ruta con numeración
+    shutil.copy(video_path, new_video_path)
+    print(f'Video copiado como {new_video_path}')
+
+
+# Uso de la función
+video_path = '/content/Vidu_Studio/video.mp4'
+output_image_path = '/tmp/img_fragmento.jpg'
+
+extraer_ultimo_fotograma(video_path, output_image_path)

Vidu/utils/jwt_reader.py

@@ -0,0 +1,9 @@
+def read_jwt_from_file(file_path):
+    try:
+        with open(file_path, "r") as file:
+            jwt_token = file.read().strip()
+        return jwt_token
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except IOError as e:
+        print(f"Error reading file: {e}")

Vidu/utils/process_task.py

@@ -0,0 +1,106 @@
+import requests
+import json
+import time
+from tqdm import tqdm
+import re  # Importar módulo de expresiones regulares
+
+def get_task_details(task_id, jwt_token):
+    url = f"https://api.vidu.studio/vidu/v1/tasks/{task_id}"
+
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio/",
+        "Referer": "https://www.vidu.studio/",
+        "Cache-Control": "no-cache",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    response = requests.get(url, headers=headers)
+    if response.status_code != 200:
+        print(f"Error fetching task details: {response.status_code}")
+        return 'ID no encontrado', 'URI no encontrado'
+
+    response_json = response.json()
+    creations = response_json.get('creations', [])
+    if creations and isinstance(creations, list) and len(creations) > 0:
+        creation_id = creations[0].get('id', 'ID no encontrado')
+        creation_uri = creations[0].get('uri', 'URI no encontrado')
+    else:
+        creation_id = 'ID no encontrado'
+        creation_uri = 'URI no encontrado'
+
+    return creation_id, creation_uri
+
+def descargar_video(uri, nombre_archivo):
+    response = requests.get(uri, stream=True)
+
+    if response.status_code == 200:
+        with open(nombre_archivo, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=1024):
+                if chunk:
+                    f.write(chunk)
+        print(f"\nVideo descargado y guardado como {nombre_archivo}")
+    else:
+        print("\nError al descargar el video")
+
+def read_file(file_path):
+    try:
+        with open(file_path, "r") as file:
+            content = file.readline().strip()  # Leer el archivo y eliminar espacios
+            return content
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error reading file: {e}")
+        return None
+
+def write_file(file_path, content):
+    try:
+        with open(file_path, "w") as file:
+            file.write(content)
+    except IOError as e:
+        print(f"Error writing file: {e}")
+
+def main():
+    task_id_path = "/tmp/task_id.txt"
+    jwt_token_path = "/tmp/jwt_token.txt"
+    creation_id_path = "/tmp/creation_id.txt"
+
+    task_id = read_file(task_id_path)
+    jwt_token = read_file(jwt_token_path)
+
+    if not task_id or not jwt_token:
+        print("No se pudo leer task_id o jwt_token. Asegúrate de que los archivos existan y contengan la información correcta.")
+        return
+
+    # Usar expresión regular para extraer solo el número del task_id en caso que esté en un formato especial
+    task_id = re.search(r'\d+', task_id).group() if task_id else None
+
+    while True:
+        with tqdm(total=10, desc="Esperando 10 segundos", ncols=80, leave=False) as pbar:
+            for _ in range(10):
+                time.sleep(1)
+                pbar.update(1)
+
+        creation_id, creation_uri = get_task_details(task_id, jwt_token)
+
+        if creation_id != 'ID no encontrado' and creation_uri != 'URI no encontrado':
+            #print(f"\nCreación encontrada: ID: {creation_id}, URI: {creation_uri}")
+            write_file(creation_id_path, creation_id)  # Guardar el creation_id en un archivo
+            descargar_video(creation_uri, "/content/Vidu_Studio/video.mp4")
+            break
+        else:
+            # Imprimir el mensaje de error en la misma línea
+            pbar.set_description("No se ha encontrado el ID o URI, intentando de nuevo...")
+            pbar.refresh()
+
+if __name__ == "__main__":
+    main()

Vidu/utils/process_task_upscale.py

@@ -0,0 +1,107 @@
+import requests
+import json
+import time
+from tqdm import tqdm
+import re  # Importar módulo de expresiones regulares
+
+def get_task_details(task_id, jwt_token):
+    url = f"https://api.vidu.studio/vidu/v1/tasks/{task_id}"
+
+    headers = {
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio/",
+        "Referer": "https://www.vidu.studio/",
+        "Cache-Control": "no-cache",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    response = requests.get(url, headers=headers)
+    if response.status_code != 200:
+        print(f"Error fetching task details: {response.status_code}")
+        return 'ID no encontrado', 'URI no encontrado'
+
+    response_json = response.json()
+    creations = response_json.get('creations', [])
+    if creations and isinstance(creations, list) and len(creations) > 0:
+        creation_id = creations[0].get('id', 'ID no encontrado')
+        creation_uri = creations[0].get('uri', 'URI no encontrado')
+    else:
+        creation_id = 'ID no encontrado'
+        creation_uri = 'URI no encontrado'
+
+    return creation_id, creation_uri
+
+def descargar_video(uri, nombre_archivo):
+    response = requests.get(uri, stream=True)
+
+    if response.status_code == 200:
+        with open(nombre_archivo, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=1024):
+                if chunk:
+                    f.write(chunk)
+        print(f"\nVideo descargado y guardado como {nombre_archivo}")
+    else:
+        print("\nError al descargar el video")
+
+def read_file(file_path):
+    try:
+        with open(file_path, "r") as file:
+            content = file.readline().strip()  # Leer el archivo y eliminar espacios
+            return content
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error reading file: {e}")
+        return None
+
+def write_file(file_path, content):
+    try:
+        with open(file_path, "w") as file:
+            file.write(content)
+    except IOError as e:
+        print(f"Error writing file: {e}")
+
+def main():
+    task_id_path = "/tmp/task_id_upscale.txt"
+    jwt_token_path = "/tmp/jwt_token.txt"
+    creation_id_path = "/tmp/creation_id.txt"
+
+    task_id = read_file(task_id_path)
+    jwt_token = read_file(jwt_token_path)
+    print(task_id)
+
+    if not task_id or not jwt_token:
+        print("No se pudo leer task_id o jwt_token. Asegúrate de que los archivos existan y contengan la información correcta.")
+        return
+
+    # Usar expresión regular para extraer solo el número del task_id en caso que esté en un formato especial
+    task_id = re.search(r'\d+', task_id).group() if task_id else None
+
+    while True:
+        with tqdm(total=10, desc="Esperando 10 segundos", ncols=80, leave=False) as pbar:
+            for _ in range(10):
+                time.sleep(1)
+                pbar.update(1)
+
+        creation_id, creation_uri = get_task_details(task_id, jwt_token)
+
+        if creation_id != 'ID no encontrado' and creation_uri != 'URI no encontrado':
+            #print(f"\nCreación encontrada: ID: {creation_id}, URI: {creation_uri}")
+            write_file(creation_id_path, creation_id)  # Guardar el creation_id en un archivo
+            descargar_video(creation_uri, "/content/Vidu_Studio/video.mp4")
+            break
+        else:
+            # Imprimir el mensaje de error en la misma línea
+            pbar.set_description("No se ha encontrado el ID o URI, intentando de nuevo...")
+            pbar.refresh()
+
+if __name__ == "__main__":
+    main()

Vidu/utils/union.py

@@ -0,0 +1,73 @@
+import os
+import subprocess
+
+def obtener_lista_videos(folder_path):
+    """
+    Obtiene una lista de archivos MP4 en el directorio especificado, ordenados por nombre.
+    
+    :param folder_path: Ruta de la carpeta donde están los videos
+    :return: Lista de rutas a los archivos de video
+    """
+    videos = [os.path.join(folder_path, filename) for filename in sorted(os.listdir(folder_path)) if filename.endswith(".mp4")]
+    return videos
+
+def crear_lista_txt(folder_path, lista_txt_path):
+    """
+    Crea un archivo de lista de texto con las rutas a los archivos MP4 en el directorio especificado.
+    
+    :param folder_path: Ruta de la carpeta donde están los videos
+    :param lista_txt_path: Ruta del archivo de lista de texto
+    """
+    videos = obtener_lista_videos(folder_path)
+    with open(lista_txt_path, 'w') as f:
+        for video in videos:
+            f.write(f"file '{video}'\n")
+
+def unir_videos_con_lista(lista_txt_path, output_video):
+    """
+    Une los videos MP4 usando un archivo de lista de texto.
+    
+    :param lista_txt_path: Ruta del archivo de lista de texto
+    :param output_video: Ruta del archivo de video de salida
+    """
+    # Verifica si ffmpeg está instalado
+    try:
+        subprocess.run(["ffmpeg", "-version"], check=True)
+    except subprocess.CalledProcessError:
+        print("ffmpeg no está instalado. Debes instalarlo.")
+        return
+    
+    # Ejecuta el comando ffmpeg para unir los videos
+    cmd = [
+        "ffmpeg", "-y", "-f", "concat", "-safe", "0", 
+        "-i", lista_txt_path, "-c", "copy", output_video
+    ]
+    subprocess.run(cmd, check=True)
+    print(f"Video combinado guardado en {output_video}")
+
+def eliminar_fragmentos(folder_path):
+    """
+    Elimina todos los archivos en el directorio especificado.
+    
+    :param folder_path: Ruta de la carpeta donde están los fragmentos
+    """
+    for archivo in os.listdir(folder_path):
+        ruta_archivo = os.path.join(folder_path, archivo)
+        if os.path.isfile(ruta_archivo):
+            os.remove(ruta_archivo)
+    print(f"Todos los fragmentos en {folder_path} han sido eliminados.")
+
+# Define las rutas
+folder_path = '/content/Vidu_Studio/video_output'  # Carpeta donde están los videos
+lista_txt_path = '/tmp/video_list.txt'  # Archivo de lista de texto
+video_salida = '/content/Vidu_Studio/video.mp4'  # Archivo de video combinado
+
+# Crear el archivo de lista de texto
+crear_lista_txt(folder_path, lista_txt_path)
+
+# Unir los videos usando el archivo de lista de texto
+unir_videos_con_lista(lista_txt_path, video_salida)
+
+# Eliminar los fragmentos después de combinar los videos
+eliminar_fragmentos(folder_path)
+

Vidu/utils/upscale_task.py

@@ -0,0 +1,100 @@
+import requests
+import json  # Para trabajar con la respuesta JSON
+import uuid
+
+def ejecutar_post(creation_id, jwt_token):
+    url = 'https://api.vidu.studio/vidu/v1/tasks'
+
+    headers = {
+        'Connection': 'keep-alive',
+        'sec-ch-ua': '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        'Accept-Language': 'en',
+        'sec-ch-ua-mobile': '?0',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
+        'content-type': 'application/json',
+        'X-Request-Id': str(uuid.uuid4()),
+        'sec-ch-ua-platform': '"Windows"',
+        'Accept': '*/*',
+        'Origin': 'https://www.vidu.studio',
+        'Sec-Fetch-Site': 'same-site',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Dest': 'empty',
+        'Referer': 'https://www.vidu.studio/',
+        'Cookie': f'JWT={jwt_token}',  # Incluir solo el JWT
+        'Cookie': f'sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0',
+        'Accept-Encoding': 'gzip, deflate'
+    }
+
+    # Datos del cuerpo de la solicitud POST
+    data = {
+        "input": {
+            "creation_id": f"{creation_id}"
+        },
+        "type": "upscale",
+        "settings": {
+            "model": "stable",
+            "duration": 4
+        }
+    }
+
+    # Realizar la solicitud POST
+    response = requests.post(url, headers=headers, json=data)
+
+    # Convertir la respuesta a JSON
+    response_json = json.loads(response.text)
+
+    # Extraer el 'id' de la respuesta
+    task_id = response_json.get('id', 'ID no encontrado')
+
+    # Mostrar la respuesta
+    print(f"Status code: {response.status_code}")
+    #print(f"Response: {response.text}")
+
+    return task_id
+
+# Función para guardar el task_id en el archivo en el formato deseado
+def guardar_task_id(task_id):
+    task_id_formateado = f"task_id: {task_id}"  # Formato deseado
+    file_path = '/tmp/task_id_upscale.txt'  # Ruta del archivo actualizada
+
+    try:
+        with open(file_path, 'w') as file:
+            file.write(task_id_formateado)
+        print(f"task_id guardado")
+    except IOError as e:
+        print(f"Error al escribir el archivo: {e}")
+
+def read_file(file_path):
+    try:
+        with open(file_path, "r") as file:
+            return file.readline().strip()
+    except FileNotFoundError:
+        print(f"Archivo no encontrado: {file_path}")
+        return None
+    except IOError as e:
+        print(f"Error al leer el archivo: {e}")
+        return None
+
+def main():
+    creation_id_path = "/tmp/creation_id.txt"
+    jwt_token_path = "/tmp/jwt_token.txt"
+
+    # Leer creation_id y jwt_token desde los archivos
+    creation_id = read_file(creation_id_path)
+    jwt_token = read_file(jwt_token_path)
+
+    if not creation_id or not jwt_token:
+        print("No se pudo leer el creation_id o jwt_token. Asegúrate de que los archivos existan y contengan la información correcta.")
+        return
+
+    # Llamar a la función para realizar el POST y obtener el task_id
+    task_id = ejecutar_post(creation_id, jwt_token)
+
+    if task_id != 'ID no encontrado':
+        # Guardar el task_id en el archivo de texto
+        guardar_task_id(task_id)
+    else:
+        print("No se pudo obtener el task_id.")
+
+if __name__ == "__main__":
+    main()

Vidu/utils/utils.py

@@ -0,0 +1,65 @@
+import re
+import random
+import string
+import requests
+
+def generar_nombre_completo():
+    """Genera un nombre completo triplicando el nombre y apellido, junto con un número aleatorio de 3 dígitos."""
+    nombres = ["Juan", "Pedro", "Maria", "Ana", "Luis", "Sofia", "Diego", "Laura", "Javier", "Isabel",
+               "Pablo", "Marta", "David", "Elena", "Sergio", "Irene", "Daniel", "Alicia", "Carlos", "Sandra",
+               "Antonio", "Lucia", "Miguel", "Sara", "Jose", "Cristina", "Alberto", "Blanca", "Alejandro", "Marta",
+               "Francisco", "Esther", "Roberto", "Silvia", "Manuel", "Patricia", "Marcos", "Victoria", "Fernando", "Rosa",
+               # Nombres comunes de EE.UU.
+               "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Charles", "Thomas",
+               "Christopher", "Daniel", "Matthew", "Anthony", "Mark", "Donald", "Steven", "Paul", "Andrew", "Joshua",
+               "Kenneth", "Kevin", "Brian", "George", "Edward", "Ronald", "Timothy", "Jason", "Jeffrey", "Ryan",
+               "Jacob", "Gary", "Nicholas", "Eric", "Jonathan", "Stephen", "Larry", "Justin", "Scott", "Brandon",
+               "Benjamin", "Samuel", "Frank", "Gregory", "Raymond", "Alexander", "Patrick", "Jack", "Dennis", "Jerry",
+               "Tyler", "Aaron", "Henry", "Douglas", "Jose", "Peter", "Adam", "Zachary", "Nathan", "Walter", 
+               "Kyle", "Harold", "Carl", "Arthur", "Gerald", "Roger", "Keith", "Jeremy", "Terry", "Lawrence",
+               "Sean", "Christian", "Ethan", "Austin", "Joe", "Jordan", "Albert", "Jesse", "Willie", "Billy"]
+
+    apellidos = ["Garcia", "Rodriguez", "Gonzalez", "Fernandez", "Lopez", "Martinez", "Sanchez", "Perez", "Alonso", "Diaz",
+                 "Martin", "Ruiz", "Hernandez", "Jimenez", "Torres", "Moreno", "Gomez", "Romero", "Alvarez", "Vazquez",
+                 "Gil", "Lopez", "Ramirez", "Santos", "Castro", "Suarez", "Munoz", "Gomez", "Gonzalez", "Navarro",
+                 "Dominguez", "Lopez", "Rodriguez", "Sanchez", "Perez", "Garcia", "Gonzalez", "Martinez", "Fernandez", "Lopez",
+                 # Apellidos comunes de EE.UU.
+                 "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez",
+                 "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson", "Thomas", "Taylor", "Moore", "Jackson", "Martin",
+                 "Lee", "Perez", "Thompson", "White", "Harris", "Sanchez", "Clark", "Ramirez", "Lewis", "Robinson",
+                 "Walker", "Young", "Allen", "King", "Wright", "Scott", "Torres", "Nguyen", "Hill", "Flores",
+                 "Green", "Adams", "Nelson", "Baker", "Hall", "Rivera", "Campbell", "Mitchell", "Carter", "Roberts",
+                 "Gomez", "Phillips", "Evans", "Turner", "Diaz", "Parker", "Cruz", "Edwards", "Collins", "Reyes",
+                 "Stewart", "Morris", "Morales", "Murphy", "Cook", "Rogers", "Gutierrez", "Ortiz", "Morgan", "Cooper",
+                 "Peterson", "Bailey", "Reed", "Kelly", "Howard", "Ward", "Cox", "Diaz", "Richardson", "Wood"]
+
+
+    nombre = random.choice(nombres)
+    apellido = random.choice(apellidos)
+    numero = random.randint(100, 999)
+
+    nombre_completo = f"{nombre}_{apellido}_{numero}"
+    return nombre_completo
+
+def generar_contrasena():
+    """Genera una contraseña aleatoria."""
+    caracteres = string.ascii_letters + "0123456789" + "#$%&/()@_-*+[]"
+    longitud = 10
+    contraseña = ''.join(random.choice(caracteres) for _ in range(longitud))
+    return contraseña
+
+def enviar_formulario(url, datos):
+    """Envía una solicitud POST a un formulario web."""
+    response = requests.post(url, data=datos)
+    return response
+
+def extraer_dominios(response_text):
+    """Extrae dominios de un texto utilizando expresiones regulares."""
+    dominios = re.findall(r'id="([^"]+\.[^"]+)"', response_text)
+    return dominios
+
+def obtener_sitio_web_aleatorio(response_text):
+    """Obtiene un sitio web aleatorio de los dominios extraídos."""
+    dominios = extraer_dominios(response_text)
+    sitio_web_aleatorio = random.choice(dominios)
+    return sitio_web_aleatorio

Vidu/utils/video_fragment.py

@@ -0,0 +1,46 @@
+import subprocess
+import os
+
+def extraer_ultimo_fotograma_ffmpeg(ruta_video, ruta_imagen):
+    """
+    Extrae el último fotograma de un video usando FFmpeg y lo guarda
+    en la ruta especificada, reemplazando el archivo si ya existe.
+
+    Args:
+        ruta_video: Ruta al archivo de video.
+        ruta_imagen: Ruta donde se guardará la imagen (incluyendo extensión).
+    """
+    # Verifica si el archivo ya existe y lo elimina si es necesario
+    if os.path.exists(ruta_imagen):
+        os.remove(ruta_imagen)
+
+    # Obtiene la duración del video
+    duracion_cmd = [
+        "ffprobe",
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        ruta_video
+    ]
+    duracion = float(subprocess.check_output(duracion_cmd))
+
+    # Calcula el tiempo para buscar cerca del final (0.1 segundos antes)
+    tiempo_busqueda = str(duracion - 0.1)
+
+    # Construye el comando FFmpeg para extraer el último fotograma
+    comando = [
+        "ffmpeg",
+        "-ss", tiempo_busqueda,  # Busca cerca del final
+        "-i", ruta_video,
+        "-vframes", "1",  # Extrae solo un fotograma
+        "-qscale:v", "2",  # Ajusta la calidad si es necesario
+        ruta_imagen
+    ]
+
+    # Ejecuta el comando FFmpeg
+    subprocess.run(comando)
+
+# Ejemplo de uso
+video_path = '/content/Vidu_Studio/videotovideo.mp4'
+output_image_path = '/tmp/img_fragmento.jpg'
+extraer_ultimo_fotograma_ffmpeg(video_path, output_image_path)

Vidu/vidu_credit.py

@@ -0,0 +1,74 @@
+import urllib.request
+import json
+import subprocess
+import argparse
+
+# Función para cargar el JWT token desde un archivo
+def cargar_jwt_token(ruta='/tmp/jwt_token.txt'):
+    try:
+        with open(ruta, 'r') as archivo:
+            jwt_token = archivo.read().strip()
+            return jwt_token
+    except FileNotFoundError:
+        print("Error: El archivo no fue encontrado.")
+        subprocess.run(["python", "/content/Vidu_Studio/main.py"], check=True)
+        return None
+
+# Función para obtener los créditos utilizando el JWT token
+def obtener_credits(jwt_token, credit_comparar):
+    url = "https://api.vidu.studio/vidu/v1/tasks/credits?type=img2video&settings.duration=4&settings.model=vidu-1"
+    headers = {
+        "Host": "api.vidu.studio",
+        "Connection": "keep-alive",
+        "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Google Chrome";v="128"',
+        "Accept-Language": "en",
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        "sec-ch-ua-platform": '"Windows"',
+        "Accept": "*/*",
+        "Origin": "https://www.vidu.studio",
+        "Sec-Fetch-Site": "same-site",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Dest": "empty",
+        "Referer": "https://www.vidu.studio/",
+        "Cookie": f"sajssdk_2015_cross_new_user=1; _ga=GA1.1.77204265.1725572952; amp_af43d4=61603120ab0445398cd1cb92fd88aef0...1i727srs7.1i727ujms.6.1.7; JWT={jwt_token}; Shunt=; sensorsdata2015jssdkcross=dfm-enc-%7B%22Va28a6y8_aV%22%3A%22sSEGIEItsRRRsHGE%22%2C%22gae28_aV%22%3A%22EGEySsGigsIHGA-AsSSHnIgEEySVVs-snAAEEHE-EsGnAAA-EGEySsGigsSisH%22%2C%22OemO2%22%3A%7B%22%24ki8r28_8eiggay_2mbeyr_8cOr%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24ki8r28_2rieyz_lrcMmeV%22%3A%22%E6%9C%AA%E5%8F%96%E5%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%2C%22%24ki8r28_ergreere%22%3A%22%22%7D%2C%22aVr68a8ar2%22%3A%22rc3liZ7ku67OV5kgPsGCiskkDskl3qmawFlJPhNcpZTowqwEpF08wX3AQXKswsPJwZwAW9NcBF3swX0JwFKJBF1cpFPMwX08wFlJPhNcpZTowq7zwqKaBv3liZ7ku67OV5kgu9G6iZHgiZNapa3cQX1Hwh1hpX3IQhycQFlJ36A%3D%22%2C%22za28mec_kmfa6_aV%22%3A%7B%226ior%22%3A%22%24aVr68a8c_kmfa6_aV%22%2C%22Cikbr%22%3A%22sSEGIEItsRRRsHGE%22%7D%7D; _ga_ZJBV7VYP55=GS1.1.1725576214.2.1.1725578996.0.0.0",
+        "Accept-Encoding": "gzip, deflate"
+    }
+
+    request = urllib.request.Request(url, headers=headers, method='GET')
+
+    try:
+        # Realizar la solicitud y obtener la respuesta
+        with urllib.request.urlopen(request) as response:
+            response_body = response.read().decode('utf-8')
+            #print("Response:", response_body)
+            data = json.loads(response_body)
+            
+            # Extraer 'current_credits' de la respuesta
+            current_credits = data.get('current_credits')
+            if current_credits is not None:
+                print(f"Current Credits: {current_credits}")
+                # Comparar los créditos y ejecutar el comando si es igual al valor proporcionado
+                if current_credits == credit_comparar or current_credits == 0:
+                    print(f"Créditos iguales a {credit_comparar}. Ejecutando /content/main.py...")
+                    subprocess.run(["python", "/content/Vidu_Studio/main.py"], check=True)
+                else:
+                    print(f"Los créditos no son {credit_comparar}.")
+            else:
+                print("No se encontró 'current_credits' en la respuesta.")
+    except urllib.error.HTTPError as e:
+        print(f"Error HTTP: {e.code}")
+        print(f"Detalles del error: {e.read().decode('utf-8')}")
+    except urllib.error.URLError as e:
+        print(f"Error de conexión: {e.reason}")
+
+# Ejecutar el script principal
+if __name__ == "__main__":
+    # Configurar el parser de argumentos
+    parser = argparse.ArgumentParser(description='Verificar créditos y ejecutar un script basado en el valor de créditos.')
+    parser.add_argument('--credit', type=int, default=4, help='El valor de créditos para comparar (predeterminado es 4).')
+    args = parser.parse_args()
+
+    jwt_token = cargar_jwt_token()
+    if jwt_token:
+        obtener_credits(jwt_token, args.credit)