User persistance ready OK!

app.py

@@ -14,14 +14,9 @@ import ast
 def perform(input1, input2, request: gr.Request):
     
     print("5.- Entré a Perform, checando persistencia...")
-    print("Estando en perform, la cantidad de tokens es (de gr.State): ", gr.State.tokens)
-    print("Estando en perform, el usuario es (de gr.State): ", gr.State.usuario)
-
-    #Probablemente a partir de aquí traeremos los datos con request y no con gr.State.
-
+        
     print("Y desde dentro de Perform, ésta es la impresión del request (de request):")
     print(request.username)
-    #Revisaremos de nuevo: 
     gr.State.tokens = sulkuPypi.getTokens(sulkuPypi.encripta(request.username).decode("utf-8")) #Todo en una línea.
     print("Ahora tienes 555: ", gr.State.tokens) 
     
@@ -55,8 +50,7 @@ def perform(input1, input2, request: gr.Request):
         #IMPORTANTE: Tienes que reconstruir capsule ahora que ya se obtiene del request, sino, capsule sera un State para el uso...
         #...de todos y es ahí donde radica el problema: 
         capsule = sulkuPypi.encripta(request.username).decode("utf-8") #decode es para quitarle el 'b
-        gr.State.capsule = capsule 
-        gr.State.tokens = sulkuPypi.debitTokens(gr.State.capsule, "picswap")
+        gr.State.tokens = sulkuPypi.debitTokens(capsule, "picswap")
         print(f"Y ahora tienes: {gr.State.tokens} tokens.")
         html_credits = tools.actualizar_creditos(gr.State.tokens)
         print(f"html credits quedó como : {html_credits} y es del tipo: {type(html_credits)}")
@@ -76,10 +70,12 @@ def display_tokens(request: gr.Request):
 
     print("182: Checando la persistencia de la información cada vez...")
     print("Ejecutando display_tokens, tienes (de gr.State): ", gr.State.tokens)
-    print("Ejecutando display_tokens, eres (de gr.State): ", gr.State.usuario)
+    
+    gr.State.tokens = sulkuPypi.getTokens(sulkuPypi.encripta(request.username).decode("utf-8"))
     display = tools.actualizar_creditos(gr.State.tokens)
     print("Y ésta es la impresión del request (de request):")
     print(request.username)
+
     return display
 
 #Inputs

auth.py

@@ -4,7 +4,7 @@ import sulkuPypi
 import time
 import ast 
 
-def authenticate(username, password, request: gr.Request) :
+def authenticate(username, password) :
 
     print("3.- Entré a authenticate...")    
         

funciones.py

@@ -1,123 +1,120 @@
-import os
-import time
-import pathlib
-from PIL import Image
-#import envCharger
-
-
-def mass(input1, input2):
-
-    # envCharger.load_env("local")
-    # PLATAFORMA = os.getenv('plataforma')
-    # print("PLATAFORMA: ", PLATAFORMA)
-    # time.sleep(5)
-    
-    #video o cualquier otro sería para imagenes.
-    modo = "pic"
-    #local o huggingface
-    plataforma = "huggingface"
-    #face_swapper o face_enhancer o la combinación de ellos.
-    procesador = "face_swapper"
-
-    print(f"Inicio: Estamos en modo {modo}, plataforma: {plataforma} y procesador: {procesador}.")
-    
-    path_video = input2
-    print("Path_video es:", path_video)
-    
-    if modo == "video":
-    
-        if plataforma == "local":
-            #Para local.
-            path_parts = path_video.split("\\")
-        else:
-            #Para HuggingFace
-            #Creo que no va en imagen.
-            print("La plataforma en la que basaremos la división es HuggingFace.")
-            path_parts = path_video.split("/")
-
-            #Aquí obtendremos nom_video
-            #Creo no va en imagen
-            filename = path_parts[-1]
-            nom_video = filename[:-4]
-            print("Esto es filename alias nom_video: ", nom_video)
-            path_particular = "/".join(path_parts[0:len(path_parts) - 1])
-            path_general = "/".join(path_parts[0:len(path_parts) - 2])
-            path_general = path_general.replace("\\", "/")
-            path_particular = path_particular.replace("\\", "/")
-            print("Path general: ", path_general)
-            print("Path general: ", path_particular)
-            path = pathlib.Path("result.mp4")
-            files = os.listdir(path_general)
-        
-            print("Estos son los files que hay:")
-            print(files)
-
-    ext_imagen = "png"
-    ext_video = "mp4"
-
-    #Selector de modo.
-    if modo == "video": 
-        print("Se asignó la extensión de video:", ext_video)
-        extension = ext_video
-    else:
-        print("Se asignó la extensión de imagen:", ext_imagen)
-        extension = ext_imagen
-
-    #El source siempre es una imagen.
-    source_path = "source.png"
-    target_path = "target." + extension
-    result_path = "result." + extension
-
-    #La primera siempre será una imagen, por eso no entra en el modo selector.
-    source_image = Image.fromarray(input1)
-    print("Esto es source_image: ", source_image)
-    source_image.save(source_path)
-        
-    #Aquí trabajaremos solo el target.
-    if modo == "video":
-        #Para Video
-        target_path = input2
-    else:
-        #Es decir si es modo imagen
-        #Para Imagenes
-        target_image = Image.fromarray(input2)
-        print("Esto es target_image: ", target_image)
-        target_image.save(target_path)
-
-    print("Después de los selectores de modo los paths quedaron así:")
-    print("source_path: ", source_path)
-    print("target_path: ", target_path)
-    
-    #FUTURE: Agrega por parámetro o mejor aún por enviroment el hecho de si es compu para usar cpu o si es hf para usar cuda o azure? 
-    #(choose from 'tensorrt', 'cuda', 'cpu')
-    command = f"python run.py -s {source_path}  -t {target_path} -o {result_path} --frame-processor {procesador} --execution-provider cpu"
-    print(command)
-    proc = os.popen(command)
-    output = proc.read()
-    print("Output (resultado de la ejecución del código):")
-    print(output)
-    print("Y el tipo del output es: ", type(output))
-    time.sleep(18)
-        
-    print("Terminó la impresión del output...")
-    
-    if "No face in source path detected" in output:
-        #Si no se detecta un rostro, pondremos un placeholder, ésto evita que se despliegue el último result obtenido antes...
-        #...de la operación fallida.
-        print("No se detectó ninguna cara en la ruta de origen.")
-        result_path = "no-source-face.png"
-        
-    else:
-        print("Si se detecto un rostro...")
-        #Si sí se detectó un rostro, sigue su camino normal.
-
-    print("Éste es el momento en el que se creo result, revisar...")    
-    
-    path = pathlib.Path(result_path)
-    path_abs = os.path.abspath(path)
-    print("Éste es el path:", path)
-    print("Y su ruta absoluta es: ", path_abs)
-    print("Listo! Gracias!")
-    return path
-    
+import os
+import time
+import pathlib
+from PIL import Image
+#import envCharger
+
+
+def mass(input1, input2):
+
+    # envCharger.load_env("local")
+    # PLATAFORMA = os.getenv('plataforma')
+    # print("PLATAFORMA: ", PLATAFORMA)
+        
+    #video o cualquier otro sería para imagenes.
+    modo = "pic"
+    #local o huggingface
+    plataforma = "huggingface"
+    #face_swapper o face_enhancer o la combinación de ellos.
+    procesador = "face_swapper"
+
+    print(f"Inicio: Estamos en modo {modo}, plataforma: {plataforma} y procesador: {procesador}.")
+    
+    path_video = input2
+    print("Path_video es:", path_video)
+    
+    if modo == "video":
+    
+        if plataforma == "local":
+            #Para local.
+            path_parts = path_video.split("\\")
+        else:
+            #Para HuggingFace
+            #Creo que no va en imagen.
+            print("La plataforma en la que basaremos la división es HuggingFace.")
+            path_parts = path_video.split("/")
+
+            #Aquí obtendremos nom_video
+            #Creo no va en imagen
+            filename = path_parts[-1]
+            nom_video = filename[:-4]
+            print("Esto es filename alias nom_video: ", nom_video)
+            path_particular = "/".join(path_parts[0:len(path_parts) - 1])
+            path_general = "/".join(path_parts[0:len(path_parts) - 2])
+            path_general = path_general.replace("\\", "/")
+            path_particular = path_particular.replace("\\", "/")
+            print("Path general: ", path_general)
+            print("Path general: ", path_particular)
+            path = pathlib.Path("result.mp4")
+            files = os.listdir(path_general)
+        
+            print("Estos son los files que hay:")
+            print(files)
+
+    ext_imagen = "png"
+    ext_video = "mp4"
+
+    #Selector de modo.
+    if modo == "video": 
+        print("Se asignó la extensión de video:", ext_video)
+        extension = ext_video
+    else:
+        print("Se asignó la extensión de imagen:", ext_imagen)
+        extension = ext_imagen
+
+    #El source siempre es una imagen.
+    source_path = "source.png"
+    target_path = "target." + extension
+    result_path = "result." + extension
+
+    #La primera siempre será una imagen, por eso no entra en el modo selector.
+    source_image = Image.fromarray(input1)
+    print("Esto es source_image: ", source_image)
+    source_image.save(source_path)
+        
+    #Aquí trabajaremos solo el target.
+    if modo == "video":
+        #Para Video
+        target_path = input2
+    else:
+        #Es decir si es modo imagen
+        #Para Imagenes
+        target_image = Image.fromarray(input2)
+        print("Esto es target_image: ", target_image)
+        target_image.save(target_path)
+
+    print("Después de los selectores de modo los paths quedaron así:")
+    print("source_path: ", source_path)
+    print("target_path: ", target_path)
+    
+    #FUTURE: Agrega por parámetro o mejor aún por enviroment el hecho de si es compu para usar cpu o si es hf para usar cuda o azure? 
+    #(choose from 'tensorrt', 'cuda', 'cpu')
+    command = f"python run.py -s {source_path}  -t {target_path} -o {result_path} --frame-processor {procesador} --execution-provider cpu"
+    print(command)
+    proc = os.popen(command)
+    output = proc.read()
+    print("Output (resultado de la ejecución del código):")
+    print(output)
+            
+    print("Terminó la impresión del output...")
+    
+    if "No face in source path detected" in output:
+        #Si no se detecta un rostro, pondremos un placeholder, ésto evita que se despliegue el último result obtenido antes...
+        #...de la operación fallida.
+        print("No se detectó ninguna cara en la ruta de origen.")
+        result_path = "no-source-face.png"
+        
+    else:
+        print("Si se detecto un rostro...")
+        #Si sí se detectó un rostro, sigue su camino normal.
+
+    print("Éste es el momento en el que se creo result, revisar...")    
+    
+    path = pathlib.Path(result_path)
+    path_abs = os.path.abspath(path)
+    print("Éste es el path:", path)
+    print("Y su ruta absoluta es: ", path_abs)
+    print("Listo! Gracias!")
+    return path
+    
     

roop/core.py

@@ -1,224 +1,224 @@
-#!/usr/bin/env python3
-import time
-import os
-import sys
-# single thread doubles cuda performance - needs to be set before torch import
-if any(arg.startswith('--execution-provider') for arg in sys.argv):
-    os.environ['OMP_NUM_THREADS'] = '1'
-# reduce tensorflow log level
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-import warnings
-from typing import List
-import platform
-import signal
-import shutil
-import argparse
-import onnxruntime
-import tensorflow
-import roop.globals
-import roop.metadata
-import roop.ui as ui
-from roop.predictor import predict_image, predict_video
-from roop.processors.frame.core import get_frame_processors_modules
-from roop.utilities import has_image_extension, is_image, is_video, detect_fps, create_video, extract_frames, get_temp_frame_paths, restore_audio, create_temp, move_temp, clean_temp, normalize_output_path
-
-warnings.filterwarnings('ignore', category=FutureWarning, module='insightface')
-warnings.filterwarnings('ignore', category=UserWarning, module='torchvision')
-
-
-def parse_args() -> None:
-    signal.signal(signal.SIGINT, lambda signal_number, frame: destroy())
-    program = argparse.ArgumentParser(formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=100))
-    program.add_argument('-s', '--source', help='select an source image', dest='source_path')
-    program.add_argument('-t', '--target', help='select an target image or video', dest='target_path')
-    program.add_argument('-o', '--output', help='select output file or directory', dest='output_path')
-    program.add_argument('--frame-processor', help='frame processors (choices: face_swapper, face_enhancer, ...)', dest='frame_processor', default=['face_swapper'], nargs='+')
-    program.add_argument('--keep-fps', help='keep target fps', dest='keep_fps', action='store_true')
-    program.add_argument('--keep-frames', help='keep temporary frames', dest='keep_frames', action='store_true')
-    program.add_argument('--skip-audio', help='skip target audio', dest='skip_audio', action='store_true')
-    program.add_argument('--many-faces', help='process every face', dest='many_faces', action='store_true')
-    program.add_argument('--reference-face-position', help='position of the reference face', dest='reference_face_position', type=int, default=0)
-    program.add_argument('--reference-frame-number', help='number of the reference frame', dest='reference_frame_number', type=int, default=0)
-    program.add_argument('--similar-face-distance', help='face distance used for recognition', dest='similar_face_distance', type=float, default=0.85)
-    program.add_argument('--temp-frame-format', help='image format used for frame extraction', dest='temp_frame_format', default='png', choices=['jpg', 'png'])
-    program.add_argument('--temp-frame-quality', help='image quality used for frame extraction', dest='temp_frame_quality', type=int, default=0, choices=range(101), metavar='[0-100]')
-    program.add_argument('--output-video-encoder', help='encoder used for the output video', dest='output_video_encoder', default='libx264', choices=['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc'])
-    program.add_argument('--output-video-quality', help='quality used for the output video', dest='output_video_quality', type=int, default=35, choices=range(101), metavar='[0-100]')
-    program.add_argument('--max-memory', help='maximum amount of RAM in GB', dest='max_memory', type=int)
-    program.add_argument('--execution-provider', help='available execution provider (choices: cpu, ...)', dest='execution_provider', default=['cpu'], choices=suggest_execution_providers(), nargs='+')
-    program.add_argument('--execution-threads', help='number of execution threads', dest='execution_threads', type=int, default=suggest_execution_threads())
-    program.add_argument('-v', '--version', action='version', version=f'{roop.metadata.name} {roop.metadata.version}')
-
-    args = program.parse_args()
-
-    roop.globals.source_path = args.source_path
-    roop.globals.target_path = args.target_path
-    roop.globals.output_path = normalize_output_path(roop.globals.source_path, roop.globals.target_path, args.output_path)
-    roop.globals.headless = roop.globals.source_path is not None and roop.globals.target_path is not None and roop.globals.output_path is not None
-    roop.globals.frame_processors = args.frame_processor
-    roop.globals.keep_fps = args.keep_fps
-    roop.globals.keep_frames = args.keep_frames
-    roop.globals.skip_audio = args.skip_audio
-    roop.globals.many_faces = args.many_faces
-    roop.globals.reference_face_position = args.reference_face_position
-    roop.globals.reference_frame_number = args.reference_frame_number
-    roop.globals.similar_face_distance = args.similar_face_distance
-    roop.globals.temp_frame_format = args.temp_frame_format
-    roop.globals.temp_frame_quality = args.temp_frame_quality
-    roop.globals.output_video_encoder = args.output_video_encoder
-    roop.globals.output_video_quality = args.output_video_quality
-    roop.globals.max_memory = args.max_memory
-    roop.globals.execution_providers = decode_execution_providers(args.execution_provider)
-    roop.globals.execution_threads = args.execution_threads
-
-
-def encode_execution_providers(execution_providers: List[str]) -> List[str]:
-    return [execution_provider.replace('ExecutionProvider', '').lower() for execution_provider in execution_providers]
-
-
-def decode_execution_providers(execution_providers: List[str]) -> List[str]:
-    return [provider for provider, encoded_execution_provider in zip(onnxruntime.get_available_providers(), encode_execution_providers(onnxruntime.get_available_providers()))
-            if any(execution_provider in encoded_execution_provider for execution_provider in execution_providers)]
-
-
-def suggest_execution_providers() -> List[str]:
-    return encode_execution_providers(onnxruntime.get_available_providers())
-
-
-def suggest_execution_threads() -> int:
-    if 'CUDAExecutionProvider' in onnxruntime.get_available_providers():
-        return 8
-    return 1
-
-
-def limit_resources() -> None:
-    # prevent tensorflow memory leak
-    gpus = tensorflow.config.experimental.list_physical_devices('GPU')
-    for gpu in gpus:
-        tensorflow.config.experimental.set_virtual_device_configuration(gpu, [
-            tensorflow.config.experimental.VirtualDeviceConfiguration(memory_limit=1024)
-        ])
-    # limit memory usage
-    if roop.globals.max_memory:
-        memory = roop.globals.max_memory * 1024 ** 3
-        if platform.system().lower() == 'darwin':
-            memory = roop.globals.max_memory * 1024 ** 6
-        if platform.system().lower() == 'windows':
-            import ctypes
-            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
-            kernel32.SetProcessWorkingSetSize(-1, ctypes.c_size_t(memory), ctypes.c_size_t(memory))
-        else:
-            import resource
-            resource.setrlimit(resource.RLIMIT_DATA, (memory, memory))
-
-
-def pre_check() -> bool:
-    if sys.version_info < (3, 9):
-        update_status('Python version is not supported - please upgrade to 3.9 or higher.')
-        return False
-    if not shutil.which('ffmpeg'):
-        update_status('ffmpeg is not installed.')
-        return False
-    return True
-
-
-def update_status(message: str, scope: str = 'ROOP.CORE') -> None:
-    print(f'[{scope}] {message}')
-    if not roop.globals.headless:
-        ui.update_status(message)
-
-
-def start() -> None:
-    for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
-        if not frame_processor.pre_start():
-            return
-    # process image to image
-    if has_image_extension(roop.globals.target_path):
-        if predict_image(roop.globals.target_path):
-            destroy()
-        shutil.copy2(roop.globals.target_path, roop.globals.output_path)
-        # process frame
-        for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
-            update_status('Progressing...', frame_processor.NAME)
-            frame_processor.process_image(roop.globals.source_path, roop.globals.output_path, roop.globals.output_path)
-            print("MOI: roop.globals.source_path es: ", roop.globals.source_path)
-            time.sleep(30)
-            frame_processor.post_process()
-        # validate image
-        if is_image(roop.globals.target_path):
-            update_status('Processing to image succeed!')
-        else:
-            update_status('Processing to image failed!')
-        return
-    # process image to videos
-    if predict_video(roop.globals.target_path):
-        destroy()
-    update_status('Creating temporary resources...')
-    create_temp(roop.globals.target_path)
-    # extract frames
-    if roop.globals.keep_fps:
-        fps = detect_fps(roop.globals.target_path)
-        update_status(f'Extracting frames with {fps} FPS...')
-        extract_frames(roop.globals.target_path, fps)
-    else:
-        update_status('Extracting frames with 30 FPS...')
-        extract_frames(roop.globals.target_path)
-    # process frame
-    temp_frame_paths = get_temp_frame_paths(roop.globals.target_path)
-    if temp_frame_paths:
-        for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
-            update_status('Progressing...', frame_processor.NAME)
-            frame_processor.process_video(roop.globals.source_path, temp_frame_paths)
-            frame_processor.post_process()
-    else:
-        update_status('Frames not found...')
-        return
-    # create video
-    if roop.globals.keep_fps:
-        fps = detect_fps(roop.globals.target_path)
-        update_status(f'Creating video with {fps} FPS...')
-        create_video(roop.globals.target_path, fps)
-    else:
-        update_status('Creating video with 30 FPS...')
-        create_video(roop.globals.target_path)
-    # handle audio
-    if roop.globals.skip_audio:
-        move_temp(roop.globals.target_path, roop.globals.output_path)
-        update_status('Skipping audio...')
-    else:
-        if roop.globals.keep_fps:
-            update_status('Restoring audio...')
-        else:
-            update_status('Restoring audio might cause issues as fps are not kept...')
-        restore_audio(roop.globals.target_path, roop.globals.output_path)
-    # clean temp
-    update_status('Cleaning temporary resources...')
-    print("No voy a limpiar el temp...")
-    time.sleep(3)
-    #clean_temp(roop.globals.target_path)
-    # validate video
-    if is_video(roop.globals.target_path):
-        update_status('Processing to video succeed!')
-    else:
-        update_status('Processing to video failed!')
-
-
-def destroy() -> None:
-    if roop.globals.target_path:
-        clean_temp(roop.globals.target_path)
-    sys.exit()
-
-
-def run() -> None:
-    parse_args()
-    if not pre_check():
-        return
-    for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
-        if not frame_processor.pre_check():
-            return
-    limit_resources()
-    if roop.globals.headless:
-        start()
-    else:
-        window = ui.init(start, destroy)
-        window.mainloop()
+#!/usr/bin/env python3
+import time
+import os
+import sys
+# single thread doubles cuda performance - needs to be set before torch import
+if any(arg.startswith('--execution-provider') for arg in sys.argv):
+    os.environ['OMP_NUM_THREADS'] = '1'
+# reduce tensorflow log level
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+import warnings
+from typing import List
+import platform
+import signal
+import shutil
+import argparse
+import onnxruntime
+import tensorflow
+import roop.globals
+import roop.metadata
+import roop.ui as ui
+from roop.predictor import predict_image, predict_video
+from roop.processors.frame.core import get_frame_processors_modules
+from roop.utilities import has_image_extension, is_image, is_video, detect_fps, create_video, extract_frames, get_temp_frame_paths, restore_audio, create_temp, move_temp, clean_temp, normalize_output_path
+
+warnings.filterwarnings('ignore', category=FutureWarning, module='insightface')
+warnings.filterwarnings('ignore', category=UserWarning, module='torchvision')
+
+
+def parse_args() -> None:
+    signal.signal(signal.SIGINT, lambda signal_number, frame: destroy())
+    program = argparse.ArgumentParser(formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=100))
+    program.add_argument('-s', '--source', help='select an source image', dest='source_path')
+    program.add_argument('-t', '--target', help='select an target image or video', dest='target_path')
+    program.add_argument('-o', '--output', help='select output file or directory', dest='output_path')
+    program.add_argument('--frame-processor', help='frame processors (choices: face_swapper, face_enhancer, ...)', dest='frame_processor', default=['face_swapper'], nargs='+')
+    program.add_argument('--keep-fps', help='keep target fps', dest='keep_fps', action='store_true')
+    program.add_argument('--keep-frames', help='keep temporary frames', dest='keep_frames', action='store_true')
+    program.add_argument('--skip-audio', help='skip target audio', dest='skip_audio', action='store_true')
+    program.add_argument('--many-faces', help='process every face', dest='many_faces', action='store_true')
+    program.add_argument('--reference-face-position', help='position of the reference face', dest='reference_face_position', type=int, default=0)
+    program.add_argument('--reference-frame-number', help='number of the reference frame', dest='reference_frame_number', type=int, default=0)
+    program.add_argument('--similar-face-distance', help='face distance used for recognition', dest='similar_face_distance', type=float, default=0.85)
+    program.add_argument('--temp-frame-format', help='image format used for frame extraction', dest='temp_frame_format', default='png', choices=['jpg', 'png'])
+    program.add_argument('--temp-frame-quality', help='image quality used for frame extraction', dest='temp_frame_quality', type=int, default=0, choices=range(101), metavar='[0-100]')
+    program.add_argument('--output-video-encoder', help='encoder used for the output video', dest='output_video_encoder', default='libx264', choices=['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc'])
+    program.add_argument('--output-video-quality', help='quality used for the output video', dest='output_video_quality', type=int, default=35, choices=range(101), metavar='[0-100]')
+    program.add_argument('--max-memory', help='maximum amount of RAM in GB', dest='max_memory', type=int)
+    program.add_argument('--execution-provider', help='available execution provider (choices: cpu, ...)', dest='execution_provider', default=['cpu'], choices=suggest_execution_providers(), nargs='+')
+    program.add_argument('--execution-threads', help='number of execution threads', dest='execution_threads', type=int, default=suggest_execution_threads())
+    program.add_argument('-v', '--version', action='version', version=f'{roop.metadata.name} {roop.metadata.version}')
+
+    args = program.parse_args()
+
+    roop.globals.source_path = args.source_path
+    roop.globals.target_path = args.target_path
+    roop.globals.output_path = normalize_output_path(roop.globals.source_path, roop.globals.target_path, args.output_path)
+    roop.globals.headless = roop.globals.source_path is not None and roop.globals.target_path is not None and roop.globals.output_path is not None
+    roop.globals.frame_processors = args.frame_processor
+    roop.globals.keep_fps = args.keep_fps
+    roop.globals.keep_frames = args.keep_frames
+    roop.globals.skip_audio = args.skip_audio
+    roop.globals.many_faces = args.many_faces
+    roop.globals.reference_face_position = args.reference_face_position
+    roop.globals.reference_frame_number = args.reference_frame_number
+    roop.globals.similar_face_distance = args.similar_face_distance
+    roop.globals.temp_frame_format = args.temp_frame_format
+    roop.globals.temp_frame_quality = args.temp_frame_quality
+    roop.globals.output_video_encoder = args.output_video_encoder
+    roop.globals.output_video_quality = args.output_video_quality
+    roop.globals.max_memory = args.max_memory
+    roop.globals.execution_providers = decode_execution_providers(args.execution_provider)
+    roop.globals.execution_threads = args.execution_threads
+
+
+def encode_execution_providers(execution_providers: List[str]) -> List[str]:
+    return [execution_provider.replace('ExecutionProvider', '').lower() for execution_provider in execution_providers]
+
+
+def decode_execution_providers(execution_providers: List[str]) -> List[str]:
+    return [provider for provider, encoded_execution_provider in zip(onnxruntime.get_available_providers(), encode_execution_providers(onnxruntime.get_available_providers()))
+            if any(execution_provider in encoded_execution_provider for execution_provider in execution_providers)]
+
+
+def suggest_execution_providers() -> List[str]:
+    return encode_execution_providers(onnxruntime.get_available_providers())
+
+
+def suggest_execution_threads() -> int:
+    if 'CUDAExecutionProvider' in onnxruntime.get_available_providers():
+        return 8
+    return 1
+
+
+def limit_resources() -> None:
+    # prevent tensorflow memory leak
+    gpus = tensorflow.config.experimental.list_physical_devices('GPU')
+    for gpu in gpus:
+        tensorflow.config.experimental.set_virtual_device_configuration(gpu, [
+            tensorflow.config.experimental.VirtualDeviceConfiguration(memory_limit=1024)
+        ])
+    # limit memory usage
+    if roop.globals.max_memory:
+        memory = roop.globals.max_memory * 1024 ** 3
+        if platform.system().lower() == 'darwin':
+            memory = roop.globals.max_memory * 1024 ** 6
+        if platform.system().lower() == 'windows':
+            import ctypes
+            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+            kernel32.SetProcessWorkingSetSize(-1, ctypes.c_size_t(memory), ctypes.c_size_t(memory))
+        else:
+            import resource
+            resource.setrlimit(resource.RLIMIT_DATA, (memory, memory))
+
+
+def pre_check() -> bool:
+    if sys.version_info < (3, 9):
+        update_status('Python version is not supported - please upgrade to 3.9 or higher.')
+        return False
+    if not shutil.which('ffmpeg'):
+        update_status('ffmpeg is not installed.')
+        return False
+    return True
+
+
+def update_status(message: str, scope: str = 'ROOP.CORE') -> None:
+    print(f'[{scope}] {message}')
+    if not roop.globals.headless:
+        ui.update_status(message)
+
+
+def start() -> None:
+    for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
+        if not frame_processor.pre_start():
+            return
+    # process image to image
+    if has_image_extension(roop.globals.target_path):
+        if predict_image(roop.globals.target_path):
+            destroy()
+        shutil.copy2(roop.globals.target_path, roop.globals.output_path)
+        # process frame
+        for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
+            update_status('Progressing...', frame_processor.NAME)
+            frame_processor.process_image(roop.globals.source_path, roop.globals.output_path, roop.globals.output_path)
+            print("MOI182: roop.globals.source_path es: ", roop.globals.source_path)
+            #time.sleep(30)
+            frame_processor.post_process()
+        # validate image
+        if is_image(roop.globals.target_path):
+            update_status('Processing to image succeed!')
+        else:
+            update_status('Processing to image failed!')
+        return
+    # process image to videos
+    if predict_video(roop.globals.target_path):
+        destroy()
+    update_status('Creating temporary resources...')
+    create_temp(roop.globals.target_path)
+    # extract frames
+    if roop.globals.keep_fps:
+        fps = detect_fps(roop.globals.target_path)
+        update_status(f'Extracting frames with {fps} FPS...')
+        extract_frames(roop.globals.target_path, fps)
+    else:
+        update_status('Extracting frames with 30 FPS...')
+        extract_frames(roop.globals.target_path)
+    # process frame
+    temp_frame_paths = get_temp_frame_paths(roop.globals.target_path)
+    if temp_frame_paths:
+        for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
+            update_status('Progressing...', frame_processor.NAME)
+            frame_processor.process_video(roop.globals.source_path, temp_frame_paths)
+            frame_processor.post_process()
+    else:
+        update_status('Frames not found...')
+        return
+    # create video
+    if roop.globals.keep_fps:
+        fps = detect_fps(roop.globals.target_path)
+        update_status(f'Creating video with {fps} FPS...')
+        create_video(roop.globals.target_path, fps)
+    else:
+        update_status('Creating video with 30 FPS...')
+        create_video(roop.globals.target_path)
+    # handle audio
+    if roop.globals.skip_audio:
+        move_temp(roop.globals.target_path, roop.globals.output_path)
+        update_status('Skipping audio...')
+    else:
+        if roop.globals.keep_fps:
+            update_status('Restoring audio...')
+        else:
+            update_status('Restoring audio might cause issues as fps are not kept...')
+        restore_audio(roop.globals.target_path, roop.globals.output_path)
+    # clean temp
+    update_status('Cleaning temporary resources...')
+    print("No voy a limpiar el temp...")
+    time.sleep(3)
+    #clean_temp(roop.globals.target_path)
+    # validate video
+    if is_video(roop.globals.target_path):
+        update_status('Processing to video succeed!')
+    else:
+        update_status('Processing to video failed!')
+
+
+def destroy() -> None:
+    if roop.globals.target_path:
+        clean_temp(roop.globals.target_path)
+    sys.exit()
+
+
+def run() -> None:
+    parse_args()
+    if not pre_check():
+        return
+    for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
+        if not frame_processor.pre_check():
+            return
+    limit_resources()
+    if roop.globals.headless:
+        start()
+    else:
+        window = ui.init(start, destroy)
+        window.mainloop()

roop/processors/frame/face_swapper.py

@@ -1,113 +1,111 @@
-from typing import Any, List, Callable
-import cv2
-import insightface
-import threading
-import requests
-import os
-import time
-
-import roop.globals
-import roop.processors.frame.core
-from roop.core import update_status
-from roop.face_analyser import get_one_face, get_many_faces
-from roop.typing import Face, Frame
-from roop.utilities import conditional_download, resolve_relative_path, is_image, is_video
-
-FACE_SWAPPER = None
-THREAD_LOCK = threading.Lock()
-NAME = 'ROOP.FACE-SWAPPER'
-
-
-def get_face_swapper() -> Any:
-    global FACE_SWAPPER
-
-    with THREAD_LOCK:
-        if FACE_SWAPPER is None:
-            
-            model_path = resolve_relative_path('../inswapper_128.onnx')
-            found = os.path.exists(model_path)
-            print("La ruta se encontró:", found)
-            time.sleep(4)
-
-            if found is True: 
-                print("Es verdad que la ruta si se encontró...")
-            else:
-                print("La ruta no se encontró por cierto...")
-                time.sleep(5)
-                print("Lo bajaré remotamente...")
-                #Ésta es la forma de bajarlo si no se encuentra en su ruta.
-                url = "https://huggingface.co/countfloyd/deepfake/resolve/main/inswapper_128.onnx"
-                response = requests.get(url)
-                content = response.content
-                path = "inswapper_128.onnx"
-                with open(path, "wb") as f:
-                    f.write(content)
-                model_path = os.path.join(os.getcwd(), path)
-
-            #También Probar cuando esté arriba en huggingface, si con la ruta relativa llega. 
-  
-
-            FACE_SWAPPER = insightface.model_zoo.get_model(model_path, providers=roop.globals.execution_providers)
-
-    return FACE_SWAPPER
-
-
-def pre_check() -> bool:
-    download_directory_path = resolve_relative_path('../content/roop')
-    #Al parecer ésto no se usa.
-    conditional_download(download_directory_path, ['https://huggingface.co/countfloyd/deepfake/resolve/main/inswapper_128.onnx'])
-    return True
-
-
-def pre_start() -> bool:
-    if not is_image(roop.globals.source_path):
-        update_status('Select an image for source path.', NAME)
-        return False
-    elif not get_one_face(cv2.imread(roop.globals.source_path)):
-        update_status('No face in source path detected.', NAME)
-        return False
-    if not is_image(roop.globals.target_path) and not is_video(roop.globals.target_path):
-        update_status('Select an image or video for target path.', NAME)
-        return False
-    return True
-
-
-def post_process() -> None:
-    global FACE_SWAPPER
-
-    FACE_SWAPPER = None
-
-
-def swap_face(source_face: Face, target_face: Face, temp_frame: Frame) -> Frame:
-    return get_face_swapper().get(temp_frame, target_face, source_face, paste_back=True)
-
-
-def process_frame(source_face: Face, temp_frame: Frame) -> Frame:
-    if roop.globals.many_faces:
-        if many_faces := get_many_faces(temp_frame):
-            for target_face in many_faces:
-                temp_frame = swap_face(source_face, target_face, temp_frame)
-    elif target_face := get_one_face(temp_frame):
-        temp_frame = swap_face(source_face, target_face, temp_frame)
-    return temp_frame
-
-
-def process_frames(source_path: str, temp_frame_paths: List[str], update: Callable[[], None]) -> None:
-    source_face = get_one_face(cv2.imread(source_path))
-    for temp_frame_path in temp_frame_paths:
-        temp_frame = cv2.imread(temp_frame_path)
-        result = process_frame(source_face, temp_frame)
-        cv2.imwrite(temp_frame_path, result)
-        if update:
-            update()
-
-
-def process_image(source_path: str, target_path: str, output_path: str) -> None:
-    source_face = get_one_face(cv2.imread(source_path))
-    target_frame = cv2.imread(target_path)
-    result = process_frame(source_face, target_frame)
-    cv2.imwrite(output_path, result)
-
-
-def process_video(source_path: str, temp_frame_paths: List[str]) -> None:
-    roop.processors.frame.core.process_video(source_path, temp_frame_paths, process_frames)
+from typing import Any, List, Callable
+import cv2
+import insightface
+import threading
+import requests
+import os
+import time
+
+import roop.globals
+import roop.processors.frame.core
+from roop.core import update_status
+from roop.face_analyser import get_one_face, get_many_faces
+from roop.typing import Face, Frame
+from roop.utilities import conditional_download, resolve_relative_path, is_image, is_video
+
+FACE_SWAPPER = None
+THREAD_LOCK = threading.Lock()
+NAME = 'ROOP.FACE-SWAPPER'
+
+
+def get_face_swapper() -> Any:
+    global FACE_SWAPPER
+
+    with THREAD_LOCK:
+        if FACE_SWAPPER is None:
+            
+            model_path = resolve_relative_path('../inswapper_128.onnx')
+            found = os.path.exists(model_path)
+            print("La ruta se encontró:", found)
+            
+            if found is True: 
+                print("Es verdad que la ruta si se encontró...")
+            else:
+                print("La ruta no se encontró por cierto...")
+                print("Lo bajaré remotamente...")
+                #Ésta es la forma de bajarlo si no se encuentra en su ruta.
+                url = "https://huggingface.co/countfloyd/deepfake/resolve/main/inswapper_128.onnx"
+                response = requests.get(url)
+                content = response.content
+                path = "inswapper_128.onnx"
+                with open(path, "wb") as f:
+                    f.write(content)
+                model_path = os.path.join(os.getcwd(), path)
+
+            #También Probar cuando esté arriba en huggingface, si con la ruta relativa llega. 
+  
+
+            FACE_SWAPPER = insightface.model_zoo.get_model(model_path, providers=roop.globals.execution_providers)
+
+    return FACE_SWAPPER
+
+
+def pre_check() -> bool:
+    download_directory_path = resolve_relative_path('../content/roop')
+    #Al parecer ésto no se usa.
+    conditional_download(download_directory_path, ['https://huggingface.co/countfloyd/deepfake/resolve/main/inswapper_128.onnx'])
+    return True
+
+
+def pre_start() -> bool:
+    if not is_image(roop.globals.source_path):
+        update_status('Select an image for source path.', NAME)
+        return False
+    elif not get_one_face(cv2.imread(roop.globals.source_path)):
+        update_status('No face in source path detected.', NAME)
+        return False
+    if not is_image(roop.globals.target_path) and not is_video(roop.globals.target_path):
+        update_status('Select an image or video for target path.', NAME)
+        return False
+    return True
+
+
+def post_process() -> None:
+    global FACE_SWAPPER
+
+    FACE_SWAPPER = None
+
+
+def swap_face(source_face: Face, target_face: Face, temp_frame: Frame) -> Frame:
+    return get_face_swapper().get(temp_frame, target_face, source_face, paste_back=True)
+
+
+def process_frame(source_face: Face, temp_frame: Frame) -> Frame:
+    if roop.globals.many_faces:
+        if many_faces := get_many_faces(temp_frame):
+            for target_face in many_faces:
+                temp_frame = swap_face(source_face, target_face, temp_frame)
+    elif target_face := get_one_face(temp_frame):
+        temp_frame = swap_face(source_face, target_face, temp_frame)
+    return temp_frame
+
+
+def process_frames(source_path: str, temp_frame_paths: List[str], update: Callable[[], None]) -> None:
+    source_face = get_one_face(cv2.imread(source_path))
+    for temp_frame_path in temp_frame_paths:
+        temp_frame = cv2.imread(temp_frame_path)
+        result = process_frame(source_face, temp_frame)
+        cv2.imwrite(temp_frame_path, result)
+        if update:
+            update()
+
+
+def process_image(source_path: str, target_path: str, output_path: str) -> None:
+    source_face = get_one_face(cv2.imread(source_path))
+    target_frame = cv2.imread(target_path)
+    result = process_frame(source_face, target_frame)
+    cv2.imwrite(output_path, result)
+
+
+def process_video(source_path: str, temp_frame_paths: List[str]) -> None:
+    roop.processors.frame.core.process_video(source_path, temp_frame_paths, process_frames)