Update app.py

app.py

@@ -14,6 +14,7 @@ HF_TOKEN = os.environ.get("HF_TOKEN") if os.environ.get("HF_TOKEN") else None #
 
 
 nb_req_simult=50 ########
+nb_gallery_model=5
 
 now2 = 0
 inference_timeout = 300
@@ -296,11 +297,13 @@ def fonc_load_info_custom(nb_of_models_to_gen,list_model_custom,index_first_mode
 def crea_list_task(id_session,list_param,list_models_to_gen,nb_images_by_prompt):
     cache_list_task[f"{id_session}"]=[]
     dict_temp={}
+    list_progress=[]
     for m in list_models_to_gen:
         dict_temp={}
         dict_temp["model"]=m
         dict_temp["id_module"]=-1
         dict_temp["task"]=[]
+        list_progress.append(0)
         for p in list_param:
             for i in range(nb_images_by_prompt):
                 dict_temp["task"].append({"prompt":p[0],"nprompt":p[1],"width":p[2],"height":p[3],"steps":p[4],"cfg":p[5],"seed":p[6]})
@@ -309,12 +312,20 @@ def crea_list_task(id_session,list_param,list_models_to_gen,nb_images_by_prompt)
     cache_text_actu[f"{id_session}"]={"nb_modules_use":nb_req_simult,"stop":False,"nb_fail":0,
                                       "nb_models_to_do":len(list_models_to_gen) ,"nb_models_tot":len(list_models_to_gen) ,
                                       "nb_tasks_to_do":len(list_models_to_gen)*len(list_param)*nb_images_by_prompt ,
-                                      "nb_tasks_tot":len(list_models_to_gen)*len(list_param)*nb_images_by_prompt }
+                                      "nb_tasks_tot":len(list_models_to_gen)*len(list_param)*nb_images_by_prompt,
+                                     "progress":list_progress,'nb_tasks_by_model': nb_images_by_prompt*len(list_param) }
 
 def fonc_update_actu(text_actu,id):
     s=""
     s+=f"modules: {cache_text_actu[str(id)]['nb_modules_use']}/{nb_req_simult}\n"
     s+=f"models remaining: {cache_text_actu[str(id)]['nb_models_to_do']}/{cache_text_actu[str(id)]['nb_models_tot']}\n"
+    i=0
+    for d in cache_text_actu[str(id)]['progress']:
+        i+=1
+        s+=str(d)
+        if i%10==0:
+            s+=" "
+    s+="\n"
     s+=f"images remaining: {cache_text_actu[str(id)]['nb_tasks_to_do']}/{cache_text_actu[str(id)]['nb_tasks_tot']}\n"
     s+=f"fail attempt: {cache_text_actu[str(id)]['nb_fail']}"
     return gr.Textbox(s)
@@ -355,15 +366,25 @@ def fonc_load_gallery(id_session,gallery):
     gallery = reset_gallery(gallery)
     for i in range(len(cache_image[f"{id_session}"])):
         gallery=add_gallery(cache_image[f"{id_session}"][i]["image"],cache_image[f"{id_session}"][i]["model"],gallery)
-    return gallery
-def fonc_load_gallery_by_model(id_session,gallery,models,index):
-    gallery = reset_gallery(gallery)
-    for i in range(len(cache_image[f"{id_session}"])):
-        if cache_image[f"{id_session}"][i]["model"]==models[index]:
-            gallery=add_gallery(cache_image[f"{id_session}"][i]["image"],cache_image[f"{id_session}"][i]["model"],gallery)
-    return gallery
+    return gr.Gallery(gallery,visible=True)
+    
+def fonc_move_gallery_by_model(id_session,gallery,index_g,models,index_m,direction):
+    delta=int((nb_gallery_model-1)/2)
+    if index_g==(index_m+(delta*direction))%nb_gallery_model :
+        gallery = reset_gallery(gallery)
+        for i in range(len(cache_image[f"{id_session}"])):
+            if cache_image[f"{id_session}"][i]["model"]==models[(index_m+(delta*direction))%len(models)]:
+                gallery=add_gallery(cache_image[f"{id_session}"][i]["image"],cache_image[f"{id_session}"][i]["model"],gallery)
+    if index_g==(index_m-direction)%nb_gallery_model:
+        return gr.Gallery(gallery,visible=False)
+        #return gr.Gallery(gallery,visible=True)
+    elif index_g==index_m%nb_gallery_model:
+        return gr.Gallery(gallery,visible=True)
+    else:
+        return gallery
+
     
-def fonc_start(id_session,id_module,s,cont):
+def fonc_start(id_session,id_module,s,cont,list_models_to_gen):
     if cont==False:
         cache_text_actu[f"{id_session}"]["nb_modules_use"]-=1
         print("manual stop")
@@ -386,6 +407,12 @@ def fonc_start(id_session,id_module,s,cont):
                     model_actu=model_plus_tasks["model"]
                     task_actu=model_plus_tasks["task"][0]
                     print(f"module num {id_module} take {model_actu}\n")
+                    i=0
+                    for model in list_models_to_gen:
+                        if model_actu==model:
+                            cache_text_actu[f"{id_session}"]['progress'][i]=1
+                        i+=1
+                    
     if model_actu=="":
         cache_text_actu[f"{id_session}"]["nb_modules_use"]-=1
         print("Stop with :"+s+"\n")
@@ -398,13 +425,20 @@ def fonc_start(id_session,id_module,s,cont):
     if result!=None:
         #result=gr.Image(result)
         id_image=len(cache_image[f"{id_session}"])
+        i=0
         for model_plus_tasks in cache_list_task[f"{id_session}"]:
             if model_plus_tasks["id_module"]==id_module:
                 model_plus_tasks["task"].remove(task_actu)
                 cache_text_actu[f"{id_session}"]["nb_tasks_to_do"]-=1
+                i=0
+                for model in list_models_to_gen:
+                    if model_actu==model:
+                        cache_text_actu[f"{id_session}"]['progress'][i]=int(((1-(len(model_plus_tasks["task"])/cache_text_actu[f"{id_session}"]["nb_tasks_by_model"]))*8)//1)+1
+                    i+=1
             if len(model_plus_tasks["task"])==0:
                 cache_list_task[f"{id_session}"].remove(model_plus_tasks)
                 cache_text_actu[f"{id_session}"]["nb_models_to_do"]-=1
+                
             
         task_actu["id_image"]=id_image
         task_actu["model"]=model_actu
@@ -426,17 +460,23 @@ def fonc_start(id_session,id_module,s,cont):
 def fonc_init(s):
     return gr.Textbox(s+"1")
 
-def index_gallery_first():
-    return gr.Number(0)
+def fonc_load_gallery_by_model(id_session,gallery,models,index_g,index_m,gallery_all): 
+    delta=int((nb_gallery_model-1)/2)
+    gallery = reset_gallery(gallery)
+    for i in range(len(cache_image[f"{id_session}"])):
+        if cache_image[f"{id_session}"][i]["model"]==models[((index_m+index_g+delta)%nb_gallery_model)-delta]:
+            gallery=add_gallery(cache_image[f"{id_session}"][i]["image"],cache_image[f"{id_session}"][i]["model"],gallery)
+    return gr.Gallery(gallery,visible=(index_g==(index_m%nb_gallery_model))), gr.Gallery(gallery_all,visible=False)#################################
+    #return gr.Gallery(gallery,visible=True), gr.Gallery(gallery_all,visible=False)
 def index_gallery_next(i,list_models):
     iT=i+1
-    return gr.Number(iT%len(list_models))
+    return gr.Number(iT%len(list_models)),gr.Number(1)
 def index_gallery_prev(i,list_models):
     iT=i-1
-    return gr.Number(iT%len(list_models))
+    return gr.Number(iT%len(list_models)),gr.Number(-1)
     
 def change_text_model_actu_gal(list_models,index):
-    return gr.Textbox(f"{list_models[index]}")
+    return gr.Textbox(f"({(index%(len(list_models)))+1}/{(len(list_models))}) {list_models[index]}")
 def fonc_add_to_text(text,list_models,index):
     return gr.Textbox(text+f"\"{list_models[index]}\",\n")
 
@@ -548,6 +588,7 @@ def make_me():
                     text_actu=gr.Textbox("",label="in progress",interactive=False,lines=6)
                     update_actu=gr.Number(0,visible=False)
                     update_actu.change(fonc_update_actu,[text_actu,id_session],[text_actu])
+                    button_start.click(fonc_update_actu,[text_actu,id_session],[text_actu])
                     with gr.Row():
                         outputs=[]
                         id_modules=[]
@@ -561,40 +602,52 @@ def make_me():
                         for o,i,s in zip(outputs,id_modules,states):
                             #o.change(fonc_start,[id_session,i],[o])
                             #o.change(test_change,[],[])
-                            s.change(fonc_start,[id_session,i,s,cont],[o,s,update_actu])
+                            s.change(fonc_start,[id_session,i,s,cont,list_models_to_gen],[o,s,update_actu])
                             #button_start.click(lambda : gr.Image(None),[],[o])
                             gen_event = gr.on(triggers=[button_start.click], fn=fonc_init,inputs=[s], outputs=[s])
                         
                         with gr.Column(scale=2):    
                             gallery = gr.Gallery(label="Output", show_download_button=True, elem_classes="gallery",
                                             interactive=False, show_share_button=True, container=True, format="png",
-                                            preview=True, object_fit="cover",columns=4,rows=4) 
+                                            preview=True, object_fit="cover",columns=4,rows=4)
+                            gallery_models=[]
+                            index_gallery=[]
+                            for i in range(nb_gallery_model):
+                                gallery_models.append(gr.Gallery(label="Output", show_download_button=True, elem_classes="gallery",
+                                            interactive=False, show_share_button=True, container=True, format="png",
+                                            preview=True, object_fit="cover",columns=4,rows=4,visible=False))
+                                index_gallery.append(gr.Number(i,visible=False))
                         with gr.Column(scale=3):
                             button_load_gallery=gr.Button("Load Gallery All")
                             button_load_gallery.click(fonc_load_gallery,[id_session,gallery],[gallery])
     
-                            index_gallery=gr.Number(-1,visible=False)
-                            button_load_gallery_first=gr.Button("Load Gallery first model")
-                            button_load_gallery_first.click(index_gallery_first,[],[index_gallery])
+                            index_gallery_m=gr.Number(0,visible=False)
+                            button_load_gallery_first=gr.Button("Init Gallery by model")
                             with gr.Row():
                                 button_load_gallery_prev=gr.Button("Prev model")
                                 button_load_gallery_next=gr.Button("Next model")
-                                button_load_gallery_next.click(index_gallery_next,[index_gallery,list_models_to_gen],[index_gallery])
-                                button_load_gallery_prev.click(index_gallery_prev,[index_gallery,list_models_to_gen],[index_gallery])
-                                index_gallery.change(fonc_load_gallery_by_model,[id_session,gallery,list_models_to_gen,index_gallery],[gallery])
+                                direction_gallery=gr.Number(0,visible=False)
+                                button_load_gallery_next.click(index_gallery_next,[index_gallery_m,list_models_to_gen],[index_gallery_m,direction_gallery])
+                                button_load_gallery_prev.click(index_gallery_prev,[index_gallery_m,list_models_to_gen],[index_gallery_m,direction_gallery])
+                                for g,i in zip(gallery_models,index_gallery):
+                                    index_gallery_m.change(fonc_move_gallery_by_model,[id_session,g,i,list_models_to_gen,index_gallery_m,direction_gallery],[g])
+                                    gen_event_gallery_first = gr.on(triggers=[button_load_gallery_first.click], fn=fonc_load_gallery_by_model,
+                                                                    inputs=[id_session,g,list_models_to_gen,i,index_gallery_m,gallery], outputs=[g,gallery])
+                                    gen_event_gallery_first_all = gr.on(triggers=[button_load_gallery.click], fn=lambda g:gr.Gallery(g,visible=False),
+                                                                    inputs=[g], outputs=[g])
                             text_model_actu_gal = gr.Textbox(label='Model Actu:', lines=1, interactive = False)
-                            index_gallery.change(change_text_model_actu_gal,[list_models_to_gen,index_gallery],[text_model_actu_gal])
+                            index_gallery_m.change(change_text_model_actu_gal,[list_models_to_gen,index_gallery_m],[text_model_actu_gal])
                             with gr.Row():
                                 with gr.Column():
                                     button_add_to_bl=gr.Button("Add to Blacklist")
                                     #button_remove_from_bl=gr.Button("Remove from Blacklist")
                                     text_bl=gr.Textbox(label='Blacklist', lines=5, interactive = True)
-                                    button_add_to_bl.click(fonc_add_to_text,[text_bl,list_models_to_gen,index_gallery],[text_bl])
-                                    #button_remove_from_bl.click(fonc_remove_from_text,[text_bl,list_models_to_gen,index_gallery],[text_bl])
+                                    button_add_to_bl.click(fonc_add_to_text,[text_bl,list_models_to_gen,index_gallery_m],[text_bl])
+                                    #button_remove_from_bl.click(fonc_remove_from_text,[text_bl,list_models_to_gen,index_gallery_m],[text_bl])
                                 with gr.Column():
                                     button_add_to_fav=gr.Button("Add to Favlist")
                                     text_fav=gr.Textbox(label='Favlist', lines=5, interactive = True)
-                                    button_add_to_fav.click(fonc_add_to_text,[text_fav,list_models_to_gen,index_gallery],[text_fav])
+                                    button_add_to_fav.click(fonc_add_to_text,[text_fav,list_models_to_gen,index_gallery_m],[text_fav])