Extras/ffff_assets/default.py

import multiprocessing
import gradio as gr
import os
import requests
import hashlib

from ffff import state_manager
from ffff.uis.components import about, age_modifier_options, common_options, execution, execution_queue_count, execution_thread_count, expression_restorer_options, face_debugger_options, face_detector, face_editor_options, face_enhancer_options, face_landmarker, face_masker, face_selector, face_swapper_options, frame_colorizer_options, frame_enhancer_options, instant_runner, job_manager, job_runner, lip_syncer_options, memory, output, output_options, preview, processors, source, target, temp_frame, terminal, trim_frame, ui_workflow


def pre_check() -> bool:
	return True


def pre_render() -> bool:
	return True

def listar_archivos():
    archivos = [f for f in os.listdir() if os.path.isfile(f)]
    return archivos


def descargar_archivo(archivo_seleccionado):
    return os.path.join(os.getcwd(), archivo_seleccionado)


def descargar_de_url(url, filename):
    local_filename = filename if filename else url.split('/')[-1]
    if len(local_filename) > 255:
        local_filename = hashlib.md5(local_filename.encode()).hexdigest()
    with requests.get(url, stream=True) as r:
        r.raise_for_status()
        with open(local_filename, 'wb') as f:
            for chunk in r.iter_content(chunk_size=8192):
                f.write(chunk)
    return local_filename


def render() -> gr.Blocks:
    with gr.Blocks() as layout:
        with gr.Row():
            with gr.Column(scale=1):
                with gr.Accordion("Columna 1", open=True):
                    about.render()
                    processors.render()
                    age_modifier_options.render()
                    expression_restorer_options.render()
                    face_debugger_options.render()
                    face_editor_options.render()
                    face_enhancer_options.render()
                    face_swapper_options.render()
                    frame_colorizer_options.render()
                    frame_enhancer_options.render()
                    lip_syncer_options.render()
                    execution.render()
                    execution_thread_count.render()
                    execution_queue_count.render()
                    memory.render()
                    temp_frame.render()
                    output_options.render()
                    script_content = """
function ClickConnect(){
    console.log("Working");
    document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click();
}
setInterval(ClickConnect,60000)
"""
                    script_box = gr.Textbox(value=script_content, label="Script para Colab", lines=10, interactive=False)
                    gr.Markdown("----") 
                    output.render()

            with gr.Column(scale=1):
                with gr.Accordion("Columna 2", open=True):
                    source.render()
                    
                    # Listado de archivos para Source
                    archivos_source = listar_archivos()
                    archivo_seleccionado_source = gr.Dropdown(label="Selecciona un archivo para Source", choices=archivos_source)
                    boton_refrescar_source = gr.Button("Refrescar Archivos Source")
                    cargar_boton_source = gr.Button("Cargar Archivo en Source")

                    def actualizar_archivos_source():
                        archivos_actualizados = listar_archivos()
                        return {"choices": archivos_actualizados}  # Devolver diccionario

                    boton_refrescar_source.click(fn=actualizar_archivos_source, inputs=[], outputs=archivo_seleccionado_source)
                    cargar_boton_source.click(fn=source.cargar_archivo, inputs=archivo_seleccionado_source, outputs=[source.SOURCE_IMAGE, source.SOURCE_VIDEO])

                    # Botón para pegar la imagen desde el portapapeles en Source
                    paste_source_button = gr.Button("Pegar del portapapeles en Source")
                    paste_source_button.click(fn=source.handle_paste, outputs=[source.SOURCE_IMAGE, source.SOURCE_VIDEO])

                    # Entrada de URL y botón para cargar desde URL en Source
                    url_input_source = gr.Textbox(label="Ingrese la URL del archivo para Source")
                    load_button_source = gr.Button("Cargar desde URL en Source")
                    load_button_source.click(fn=source.handle_url_input, inputs=url_input_source, outputs=[source.SOURCE_IMAGE, source.SOURCE_VIDEO])

                    gr.Markdown("----") 

                    target.render()

                    # Listado de archivos para Target
                    archivos_target = listar_archivos()
                    archivo_seleccionado_target = gr.Dropdown(label="Selecciona un archivo para Target", choices=archivos_target)
                    boton_refrescar_target = gr.Button("Refrescar Archivos Target")
                    cargar_boton_target = gr.Button("Cargar Archivo en Target")

                    def actualizar_archivos_target():
                        archivos_actualizados = listar_archivos()
                        return {"choices": archivos_actualizados}  # Devolver diccionario

                    boton_refrescar_target.click(fn=actualizar_archivos_target, inputs=[], outputs=archivo_seleccionado_target)
                    cargar_boton_target.click(fn=target.cargar_archivo, inputs=archivo_seleccionado_target, outputs=[target.TARGET_IMAGE, target.TARGET_VIDEO])

                    # Botón para pegar la imagen desde el portapapeles en Target
                    paste_target_button = gr.Button("Pegar del portapapeles en Target")
                    paste_target_button.click(fn=target.handle_paste, outputs=[target.TARGET_IMAGE, target.TARGET_VIDEO])

                    # Entrada de URL y botón para cargar desde URL en Target
                    url_input_target = gr.Textbox(label="Ingrese la URL del archivo para Target")
                    load_button_target = gr.Button("Cargar desde URL en Target")
                    load_button_target.click(fn=target.handle_url_input, inputs=url_input_target, outputs=[target.TARGET_IMAGE, target.TARGET_VIDEO])

                    terminal.render()
                    ui_workflow.render()
                    instant_runner.render()
                    job_runner.render()
                    job_manager.render()

            with gr.Column(scale=3):
                with gr.Accordion("Columna 3", open=True):
                    preview.render()
                    trim_frame.render()
                    face_selector.render()
                    face_masker.render()
                    face_detector.render()
                    face_landmarker.render()
                    common_options.render()

                    gr.Markdown("----") 

                    # Nueva sección para descargar archivo desde URL
                    url_input = gr.Textbox(label="Ingrese URL para descargar archivo", placeholder="https://ejemplo.com/archivo.png")
                    filename_input = gr.Textbox(label="Nombre del archivo para descargar (con extensión)", placeholder="archivo.png")
                    download_button = gr.Button("Descargar Archivo")
                    download_output = gr.Textbox(label="Ruta del Archivo Descargado", interactive=False)

                    def handle_download(url, filename):
                        local_file = descargar_de_url(url, filename)
                        return local_file

                    download_button.click(handle_download, inputs=[url_input, filename_input], outputs=download_output)

                    gr.Markdown("----") 

                    archivos = listar_archivos()
                    archivo_seleccionado = gr.Dropdown(label="Selecciona un archivo", choices=archivos)
                    boton_refrescar = gr.Button("Refrescar Archivos")
                    boton_descargar = gr.Button("Descargar Archivo")
                    output_descarga = gr.File(label="Archivo Descargado")

                    def actualizar_archivos():
                        archivos_actualizados = listar_archivos()
                        return {"choices": archivos_actualizados}  # Devolver diccionario con las nuevas opciones

                    boton_refrescar.click(fn=actualizar_archivos, inputs=[], outputs=archivo_seleccionado)
                    boton_descargar.click(fn=descargar_archivo, inputs=archivo_seleccionado, outputs=output_descarga)

    return layout


def listen() -> None:
	processors.listen()
	age_modifier_options.listen()
	expression_restorer_options.listen()
	face_debugger_options.listen()
	face_editor_options.listen()
	face_enhancer_options.listen()
	face_swapper_options.listen()
	frame_colorizer_options.listen()
	frame_enhancer_options.listen()
	lip_syncer_options.listen()
	execution.listen()
	execution_thread_count.listen()
	execution_queue_count.listen()
	memory.listen()
	temp_frame.listen()
	output_options.listen()
	source.listen()
	target.listen()
	output.listen()
	instant_runner.listen()
	job_runner.listen()
	job_manager.listen()
	terminal.listen()
	preview.listen()
	trim_frame.listen()
	face_selector.listen()
	face_masker.listen()
	face_detector.listen()
	face_landmarker.listen()
	common_options.listen()


def run(ui: gr.Blocks) -> None:
  concurrency_count = min(8, multiprocessing.cpu_count())
  ui.launch(favicon_path = 'ffff.ico', inbrowser = state_manager.get_item('open_browser'),share=True)