Reauth

app.py

@@ -0,0 +1,157 @@
+import gradio as gr
+import sulkuPypi
+from funciones import mass
+from data import usuarios
+import encrypter
+import time
+import nycklar.nodes
+
+#Funciones
+def authenticate(username, password):
+    
+    for u, p in usuarios:
+        #Si el usuario y la contraseña son correctas...
+        if username == u and password == p:
+            #Agrego el nombre del usuario al estado general.
+            gr.State.usuario = username
+            #Bienvenida al usuario...
+            print("Welcome ", gr.State.usuario)
+
+            #Capsule es el usuario encriptado que enviarás a la API de Sulku.
+            capsule = encrypter.encripta(gr.State.usuario).decode("utf-8") #decode es para quitarle el 'b
+            gr.State.capsule = capsule            
+
+            #Checa cuantos tokens tiene ese usuario via la API de Sulku: 
+            gr.State.tokens = sulkuPypi.getTokens(capsule)
+            
+            print(f"Tienes: {gr.State.tokens} tokens. ")
+            
+            return True
+    #Si no hubo coincidencia regresas un false.    
+    return False
+
+#Función principal
+def perform(input1, input2):
+  
+    print("Estando en perform182, la cantidad de tokens es: ", gr.State.tokens)
+    #Revisaremos de nuevo: 
+    gr.State.tokens = sulkuPypi.getTokens(encrypter.encripta(gr.State.usuario).decode("utf-8")) #Todo en una línea.
+    print("Ahora tienes: ", gr.State.tokens) 
+    
+    #Después autoriza.
+    #Si está autorizada puede ejecutar la tarea, ésta lógica si está a cargo aquí, por parte de la app y su desarrollador, no de Sulku.
+    autorizacion = sulkuPypi.authorize(gr.State.tokens, 'picswap')
+    print("La autorización es: ", autorizacion)
+
+    info_window = ""
+
+    #Después ejecuta la masa.
+    if autorizacion is True: 
+    
+        path = mass(input1,input2)
+
+    else:
+        info_window = "Out of credits..."
+        path = 'no-result.png'
+        return path, info_window, btn_buy
+
+    print(f"El path final fue {path}, si es no-result, no debites y controla la info window.")
+    print(f"El type de path es: ", type(path))
+    
+
+    print("Convirtiendo path a string...")
+    path_string = str(path)
+    
+    
+    print("Path_string = ", path_string)
+
+    if "no-result" not in path_string:
+        #Si el path NO tiene no-result, todo funcionó bien, por lo tanto debita.
+        print("Se obtuvo un resultado, debitaremos.")
+        #Y finalmente debita los tokens.
+        gr.State.tokens = sulkuPypi.debitTokens(gr.State.capsule, "picswap")
+        print(f"Y ahora tienes: {gr.State.tokens} tokens.")
+        info_window = "Image ready!"
+        
+    else:
+        print("No se detectó un rostro...")
+        info_window = "No face in source path detected."
+        print(f"Y ahora tienes: {gr.State.tokens} tokens.")
+        lbl_credits = "Nuevo texto..."
+        #No se hizo un proceso, por lo tanto no debitaremos.
+        #En el futuro, como regla de negocio, podría cambiar y que si debitemos.  
+    
+    return path, info_window, btn_buy
+
+def click_buy():
+
+    print("Ejecutando change...")
+
+    nuevo_markdown =  """
+    
+    """
+
+    return nuevo_markdown
+
+def display_tokens():
+
+    print("Ejecutando display_tokens...")
+
+    return gr.State.tokens
+
+#LOCAL VARIABLES
+# gr.State.usuario = "briggsboardman"
+# Capsule es el usuario encriptado que enviarás a la API de Sulku.
+# capsule = encrypter.encripta(gr.State.usuario).decode("utf-8") #decode es para quitarle el 'b
+# gr.State.capsule = capsule
+# gr.State.tokens = 20
+
+
+#Inputs
+source_image = gr.Image(label="Source")
+destination_image = gr.Image(label="Destination")
+
+#Outputs
+result_image = gr.Image(label="Blend Result")
+txt_credits = gr.Textbox(label="Credits Available", value="205", interactive=False)
+html_credits = gr.HTML("<div>Credits = 205</div>")
+lbl_console = gr.Label(label="AI Terminal Messages", value="AI Engine ready...", container=True)
+btn_buy = gr.Button("Buy More", visible=True, size='lg')
+#btn_buy.click(fn=click_buy, outputs=mrk_title)
+
+#Gradio themes: 
+# — gr.themes.Base()
+# — gr.themes.Default()
+# — gr.themes.Glass()
+# — gr.themes.Monochrome()
+# — gr.themes.Soft()
+
+#valor = gr.State.tokens
+valor = "205"
+
+with gr.Blocks(theme=gr.themes.Base(), css="footer {visibility: hidden}") as main:   
+
+    with gr.Row():        
+        gr.Markdown(visible=True)
+        gr.Markdown(visible=True)
+        gr.Markdown(visible=True)
+        lbl_credits = gr.Label(label="Credits Available", value=valor, scale=1)        
+        result_image.change(fn=display_tokens, outputs=lbl_credits)
+   
+    with gr.Row():
+
+        demo = gr.Interface(
+            fn=perform,
+            title="", 
+            inputs=[source_image, destination_image], 
+            outputs=[result_image, lbl_console, txt_credits, btn_buy], 
+            allow_flagging='auto'
+            )
+        
+    with gr.Row():
+        gr.Markdown(visible=True)        
+        gr.Markdown(visible=True)
+        gr.Markdown(visible=True)
+        lbl_credits = gr.Textbox(label="Credits Available", value="205", interactive=False, scale=1)
+
+main.launch(auth=authenticate)

funciones.py

@@ -0,0 +1,124 @@
+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 asigno la extensión de video:", ext_video)
+        extension = ext_video
+    else:
+        print("Se asigno 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)
+    time.sleep(1)
+    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(1)
+    
+    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-result.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
+    
+