import os import gradio as gr from random import randint from operator import itemgetter import bisect from all_models import tags_plus_models,models,models_plus_tags,find_warm_model_list from datetime import datetime from externalmod import gr_Interface_load import asyncio import os from threading import RLock lock = RLock() HF_TOKEN = os.environ.get("HF_TOKEN") if os.environ.get("HF_TOKEN") else None # If private or gated models aren't used, ENV setting is unnecessary. nb_req_simult=80 ######## max_pending=3 nb_gallery_model=5 tempo_update_actu=3.0 #incr_update_actu={} now2 = 0 inference_timeout = 300 inference_timeout_w = 70 inference_timeout_wp = 120 MAX_SEED = 2**32-1 nb_rep=2 nb_mod_dif=20 nb_models=nb_mod_dif*nb_rep cache_image={} cache_id_image={} cache_list_task={} cache_text_actu={} from_reload={} cache_list_task_w={} def load_fn(models): global models_load global num_models global default_models models_load = {} num_models = len(models) i=0 if num_models!=0: default_models = models[:num_models] else: default_models = {} for model in models: i+=1 if i%50==0: print("\n\n\n-------"+str(i)+'/'+str(len(models))+"-------\n\n\n") if model not in models_load.keys(): try: m = gr_Interface_load(f'models/{model}', hf_token=HF_TOKEN) except Exception as error: m = gr.Interface(lambda txt: None, ['text'], ['image']) print(error) models_load.update({model: m}) load_fn(models) tags_plus_models_to_list=[] list_tags=[] for tag_plus_m in tags_plus_models: list_tags.append(tag_plus_m[0]+f" ({tag_plus_m[1]})") models_publ=[] if len(models)>10: nb_publ=10 else: nb_publ=len(models) for i in range(nb_publ): models_publ.append(models[i]) def test_pass_aff(test): if test==os.getenv('p'): return gr.Tab(visible=True) else: return gr.Tab(visible=False) # https://huggingface.co/docs/api-inference/detailed_parameters # https://huggingface.co/docs/huggingface_hub/package_reference/inference_client async def infer(model_str, prompt, nprompt="", height=None, width=None, steps=None, cfg=None, seed=-1, timeout=inference_timeout): from pathlib import Path kwargs = {} if height is not None and height >= 256: kwargs["height"] = height if width is not None and width >= 256: kwargs["width"] = width if steps is not None and steps >= 1: kwargs["num_inference_steps"] = steps if cfg is not None and cfg > 0: cfg = kwargs["guidance_scale"] = cfg if seed >= 0: kwargs["seed"] = seed else: kwargs["seed"] = randint(1, MAX_SEED-1) task = asyncio.create_task(asyncio.to_thread(models_load[model_str].fn, prompt=prompt, negative_prompt=nprompt, **kwargs, token=HF_TOKEN)) await asyncio.sleep(3) try: result = await asyncio.wait_for(task, timeout=timeout) except (Exception, asyncio.TimeoutError) as e: print(e) print(f"Task timed out: {model_str}") if not task.done(): task.cancel() result = None if task.done() and result is not None: with lock: nb_rand1=randint(1, MAX_SEED) nb_rand2=randint(1, MAX_SEED) nb_rand3=randint(1, MAX_SEED) png_path = f"image_{nb_rand1}_{nb_rand2}_{nb_rand3}.png" result.save(png_path) image = str(Path(png_path).resolve()) return image return None def gen_fn(model_str, prompt, nprompt="", height=None, width=None, steps=None, cfg=None, seed=-1,timeout=inference_timeout): if model_str == 'NA': return None try: loop = asyncio.new_event_loop() result = loop.run_until_complete(infer(model_str, prompt, nprompt, height, width, steps, cfg, seed, timeout)) except (Exception, asyncio.CancelledError) as e: print(e) print(f"Task aborted: {model_str}") result = None finally: loop.close() return result def add_gallery(image, model_str, gallery): if gallery is None: gallery = [] #with lock: if image is not None: gallery.append((image, model_str)) return gallery def reset_gallery(gallery): return add_gallery(None,"",[]) def load_gallery(gallery,id): gallery = reset_gallery(gallery) for c in cache_image[f"{id}"]: gallery=add_gallery(c[0],c[1],gallery) return gallery def load_gallery_sorted(gallery,id): gallery = reset_gallery(gallery) for c in sorted(cache_image[f"{id}"], key=itemgetter(1)): gallery=add_gallery(c[0],c[1],gallery) return gallery def add_cache_image(image, model_str,id,cache_image=cache_image): if image is not None: cache_image[f"{id}"].append((image,model_str)) #cache_image=sorted(cache_image, key=itemgetter(1)) return def reset_cache_image(id,cache_image=cache_image): cache_image[f"{id}"].clear() return def reset_cache_image_all_sessions(cache_image=cache_image): for key, listT in cache_image.items(): listT.clear() return def set_session(id,warm=False): if id==0: randTemp=randint(1,MAX_SEED) cache_image[f"{randTemp}"]=[] cache_id_image[f"{randTemp}"]=[] cache_list_task[f"{randTemp}"]=[] cache_text_actu[f"{randTemp}"]={} if warm: cache_text_actu[f"{randTemp}"]["warm"]=True else: cache_text_actu[f"{randTemp}"]["warm"]=False from_reload[f"{randTemp}"]=False cache_list_task_w[f"{randTemp}"]=[] #incr_update_actu[f"{randTemp}"]=0 return gr.Number(visible=False,value=randTemp) else : return id def fonc_restore_session(id): from_reload[f"{id}"]=True list_param=[] list_models=[] for m in cache_list_task[f"{id}"]: if m["model"] not in list_models: list_models.append(m["model"]) for t in m["task"]: if [t["prompt"],t["nprompt"],t["width"],t["height"],t["steps"],t["cfg"],t["seed"]] not in list_param: list_param.append([t["prompt"],t["nprompt"],t["width"],t["height"],t["steps"],t["cfg"],t["seed"]]) for t in cache_image[f"{id}"]: if t["model"] not in list_models : list_models.append(t["model"]) if [t["prompt"],t["nprompt"],t["width"],t["height"],t["steps"],t["cfg"],t["seed"]] not in list_param: list_param.append([t["prompt"],t["nprompt"],t["width"],t["height"],t["steps"],t["cfg"],t["seed"]]) cache_text_actu[f"{id}"]["nb_modules_use"]=nb_req_simult cache_text_actu[f"{id}"]["stop"]=False return gr.Dropdown(choices=[["a",list_param]], value=list_param) ,gr.Dataset(samples=list_param), list_models , len(list_models) def print_info_sessions(): lenTot=0 s="" s+="number of sessions : "+str(len(cache_image))+"\n" for key, listT in cache_image.items(): s+="session "+key+" : "+str(len(listT))+"\n" lenTot+=len(listT) s+="images total = "+str(lenTot)+"\n" return s def disp_models(group_model_choice,nb_rep=nb_rep): listTemp=[] strTemp='\n' i=0 for m in group_model_choice: if m not in listTemp: listTemp.append(m) for m in listTemp: i+=1 strTemp+="\"" + m + "\",\n" if i%(8/nb_rep)==0: strTemp+="\n" return gr.Textbox(label="models",value=strTemp) def search_models(str_search,tags_plus_models=tags_plus_models): output1="\n" output2="" for m in tags_plus_models[0][2]: if m.find(str_search)!=-1: output1+="\"" + m + "\",\n" outputPlus="\n From tags : \n\n" for tag_plus_models in tags_plus_models: if str_search.lower() == tag_plus_models[0].lower() and str_search!="": for m in tag_plus_models[2]: output2+="\"" + m + "\",\n" if output2 != "": output=output1+outputPlus+output2 else : output=output1 return gr.Textbox(label="out",value=output) def search_info(txt_search_info,models_plus_tags=models_plus_tags): outputList=[] if txt_search_info.find("\"")!=-1: start=txt_search_info.find("\"")+1 end=txt_search_info.find("\"",start) m_name=cutStrg(txt_search_info,start,end) else : m_name = txt_search_info for m in models_plus_tags: if m_name == m[0]: outputList=m[1] if len(outputList)==0: outputList.append("Model Not Find") return gr.Textbox(label="out",value=outputList) def ratio_chosen(choice_ratio,width,height): if choice_ratio == [None,None]: return width , height else : return gr.Slider(label="Width", info="If 0, the default value is used.", maximum=2024, step=32, value=choice_ratio[0]), gr.Slider(label="Height", info="If 0, the default value is used.", maximum=2024, step=32, value=choice_ratio[1]) list_ratios=[["None",[None,None]], ["4:1 (2048 x 512)",[2048,512]], ["12:5 (1536 x 640)",[1536,640]], ["~16:9 (1344 x 768)",[1344,768]], ["~3:2 (1216 x 832)",[1216,832]], ["~4:3 (1152 x 896)",[1152,896]], ["1:1 (1024 x 1024)",[1024,1024]], ["~3:4 (896 x 1152)",[896,1152]], ["~2:3 (832 x 1216)",[832,1216]], ["~9:16 (768 x 1344)",[768,1344]], ["5:12 (640 x 1536)",[640,1536]], ["1:4 (512 x 2048)",[512,2048]]] def fonc_add_param(lp,txt_input,neg_input,width,height,steps,cfg,seed):########################################### if lp == [["","",0,0,0,0,-1]]: lp.remove(["","",0,0,0,0,-1]) #lp.append([txt_input,neg_input,width,height,steps,cfg,seed]) list_txt=txt_input.split("/") for t in list_txt: lp.append([t,neg_input,width,height,steps,cfg,seed]) return gr.Dataset(samples=lp) , gr.Dropdown(choices=[["a",lp]], value=lp) def fonc_del_param(lp,txt_input,neg_input,width,height,steps,cfg,seed): if [txt_input,neg_input,width,height,steps,cfg,seed] in lp : lp.remove([txt_input,neg_input,width,height,steps,cfg,seed]) if lp == []: lp.append(["","",0,0,0,0,-1]) return gr.Dataset(samples=lp) , gr.Dropdown(choices=[["a",lp]], value=lp) def fonc_load_info(nb_of_models_to_gen,index_tag,index_first_model): str_temp="" list_models_temp=[] if index_first_model+nb_of_models_to_gen>len(tags_plus_models[index_tag][2]): if nb_of_models_to_gen>len(tags_plus_models[index_tag][2]): str_temp+="warning : to many model chosen" else: str_temp+="warning : first model to close to the last model" nb_of_models_to_gen= len(tags_plus_models[index_tag][2])-index_first_model str_temp+=f" - only {nb_of_models_to_gen} will be use\n\n" str_temp+="list of models use (from " str_temp+=f"{index_first_model+1}/{len(tags_plus_models[index_tag][2])} to {index_first_model+nb_of_models_to_gen}/{len(tags_plus_models[index_tag][2])}) :\n\n" for i in range(nb_of_models_to_gen): list_models_temp.append(tags_plus_models[index_tag][2][i+index_first_model]) str_temp+=f"\"{tags_plus_models[index_tag][2][i+index_first_model]}\",\n" return nb_of_models_to_gen,gr.Textbox(str_temp),gr.Dropdown(choices=[["",list_models_temp]], value=list_models_temp ) def load_random_models(nb_of_models_to_gen,index_tag): str_temp="" list_models_temp=[] list_random=[] if nb_of_models_to_gen>=len(tags_plus_models[index_tag][2]): str_temp+="warning : to many model chosen" nb_of_models_to_gen= len(tags_plus_models[index_tag][2]) str_temp+=f" - only {nb_of_models_to_gen} will be use\n\n" list_models_temp=tags_plus_models[index_tag][2] for m in list_models_temp: str_temp+=f"\"{m}\",\n" else : list_random=tags_plus_models[index_tag][2].copy() for i in range(nb_of_models_to_gen): i_rand=randint(0,len(list_random)-1) m=list_random.pop(i_rand) list_models_temp.append(m) str_temp+=f"\"{m}\",\n" return nb_of_models_to_gen,gr.Textbox(str_temp),gr.Dropdown(choices=[["",list_models_temp]], value=list_models_temp ) def fonc_load_info_custom(nb_of_models_to_gen,list_model_custom,index_first_model): str_temp="" list_models_temp=[] if index_first_model+nb_of_models_to_gen>len(list_model_custom): if nb_of_models_to_gen>len(list_model_custom): str_temp+="warning : to many model chosen" else: str_temp+="warning : first model to close to the last model" nb_of_models_to_gen= len(list_model_custom)-index_first_model str_temp+=f" - only {nb_of_models_to_gen} will be use\n\n" str_temp+="list of models CUSTOM use (from " str_temp+=f"{index_first_model+1}/{len(list_model_custom)} to {index_first_model+nb_of_models_to_gen}/{len(list_model_custom)}) :\n\n" for i in range(nb_of_models_to_gen): list_models_temp.append(list_model_custom[i+index_first_model]) str_temp+=f"\"{list_model_custom[i+index_first_model]}\",\n" return nb_of_models_to_gen,gr.Textbox(str_temp),gr.Dropdown(choices=[["",list_models_temp]], value=list_models_temp ) def crea_list_task(id_session,list_param,list_models_to_gen,nb_images_by_prompt): if from_reload[f"{id_session}"]==True: from_reload[f"{id_session}"]=False return 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["pending_task"]=0 dict_temp["task"]=[] list_progress.append(0) index_prompt=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],"index_prompt":index_prompt}) index_prompt+=1 cache_list_task[f"{id_session}"].append(dict_temp) cache_text_actu[f"{id_session}"]={"nb_modules_use":nb_req_simult,"stop":False,"nb_fail":0,"warm":False, "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, "progress":list_progress,'nb_tasks_by_model': nb_images_by_prompt*len(list_param), "nb_warm_in_use":0} 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+=" " if i%50==0: s+="\n" 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) def fonc_update_actu_2(id): if id == 0 : return gr.Textbox("waiting...") if cache_text_actu[str(id)]['warm']==True: return gr.Textbox("waiting...") s="" i=0 nb_ones=0 for d in cache_text_actu[str(id)]['progress']: i+=1 if d==1: nb_ones+=1 s+=str(d) if i%10==0: s+=" " if i%50==0: s+="\n" s+="\n" s+=f"modules: {cache_text_actu[str(id)]['nb_modules_use']}/{nb_req_simult} ({nb_ones}/{cache_text_actu[str(id)]['nb_modules_use']})\n" s+=f"models remaining: {cache_text_actu[str(id)]['nb_models_to_do']}/{cache_text_actu[str(id)]['nb_models_tot']}\n" s+=f"images remaining(done): {cache_text_actu[str(id)]['nb_tasks_to_do']}({cache_text_actu[str(id)]['nb_tasks_tot']-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']}\n" s+=f"warm task pending = {cache_text_actu[str(id)]['nb_warm_in_use']}\n" #s+=f"{tempo_update_actu*incr_update_actu[str(id)]} s" #incr_update_actu[str(id)]+=1 s+=f"{randint(1,MAX_SEED)}" return gr.Textbox(s) def cutStrg(longStrg,start,end): shortStrg='' for i in range(end-start): shortStrg+=longStrg[start+i] return shortStrg def aff_models_perso(txt_list_perso,models=models): list_perso=[] t1=True start=txt_list_perso.find('\"') if start!=-1: while t1: start+=1 end=txt_list_perso.find('\"',start) if end != -1: txtTemp=cutStrg(txt_list_perso,start,end) if txtTemp in models: list_perso.append(cutStrg(txt_list_perso,start,end)) else : t1=False start=txt_list_perso.find('\"',end+1) if start==-1: t1=False return gr.Dropdown(choices=[["",list_perso]], value=list_perso ) def add_gallery(image, model_str, gallery): if gallery is None: gallery = [] #with lock: if image is not None: gallery.append((image, model_str)) return gallery def reset_gallery(gallery): return add_gallery(None,"",[]) 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 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) list_image_temp=[] 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)]: list_image_temp.append([cache_image[f"{id_session}"][i]["image"],cache_image[f"{id_session}"][i]["model"],cache_image[f"{id_session}"][i]["index_prompt"]]) for temp in sorted(list_image_temp,key=itemgetter(2)): gallery=add_gallery(temp[0],temp[1],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,list_models_to_gen): if cont==False: cache_text_actu[f"{id_session}"]["nb_modules_use"]-=1 print("manual stop") return None,gr.Textbox(s),gr.Number(randint(1,MAX_SEED)) task_actu={} model_actu="" use_warm_model=False print(f"in fonc : id module={id_module}\n") warm_models , models_plus_tags_temp = find_warm_model_list("John6666", ["stable-diffusion-xl"], "", "last_modified", 10000) for model_plus_tasks in cache_list_task[f"{id_session}"]: if model_actu == "": if model_plus_tasks["model"] in warm_models: if model_plus_tasks["pending_task"]=nb_modules: cache_text_actu[f"{id_session}"]["nb_modules_use"]-=1 print("manual stop") return None,gr.Textbox(s),gr.Number(randint(1,MAX_SEED)) find_task=False task={} for t in cache_list_task_w[f"{id_session}"]: if not find_task: if t[0]>0: t[0]-=1 t[2]+=1 task=t[1].copy() find_task=True if not find_task: cache_text_actu[f"{id_session}"]["nb_modules_use"]-=1 return None,gr.Textbox(s),gr.Number(randint(1,MAX_SEED)) if tag == "": tagT=["stable-diffusion-xl"] else: tagT=["stable-diffusion-xl",tag] models_temp , models_plus_tags_temp = find_warm_model_list("John6666", tagT, "", "last_modified", 10000) models_rand=[] for m in models_temp: if m in models: models_rand.append(m) if len(models_rand)!=0: model_actu=models_temp[randint(0,len(models_rand)-1)] print(f"find model : {model_actu}") else: print("no warm model") cache_text_actu[f"{id_session}"]["nb_modules_use"]-=1 return None,gr.Textbox(s),gr.Number(randint(1,MAX_SEED)) print("begin gen image:") print(model_actu) print(task) result=gen_fn(model_actu, task["prompt"], task["nprompt"], task["height"], task["width"], task["steps"], task["cfg"], task["seed"],inference_timeout_w) print("reception") if result!=None: id_image=len(cache_image[f"{id_session}"]) for t in cache_list_task_w[f"{id_session}"]: if t[1]==task: t[2]-=1 if t[0]+t[2]<=0: cache_list_task_w[f"{id_session}"].remove(t) cache_text_actu[f"{id_session}"]["nb_prompt_to_do"]-=1 ################################# cache_text_actu[f"{id_session}"]["nb_tasks_to_do"]-=1 task["id_image"]=id_image task["model"]=model_actu task["image"]=result cache_image[f"{id_session}"].append(task) print("image saved\n") print(task) else: for t in cache_list_task_w[f"{id_session}"]: if t[1]==task: t[0]+=1 t[2]-=1 cache_text_actu[f"{id_session}"]["nb_fail"]+=1 print("fail to generate\n") nb_task_to_do=cache_text_actu[str(id_session)]["nb_tasks_to_do"] print(f"\n {nb_task_to_do} tasks to do\n") return result , gr.Textbox(s+"1"),gr.Number(randint(1,MAX_SEED)) def fonc_update_actu_w(id): if id == 0 : return gr.Textbox("waiting...") if cache_text_actu[str(id)]['warm']==False: return gr.Textbox("waiting...") s="" s+=f"modules: {cache_text_actu[str(id)]['nb_modules_use']}/{nb_req_simult} \n" s+=f"prompts remaining: {cache_text_actu[str(id)]['nb_prompt_to_do']}/{cache_text_actu[str(id)]['nb_prompt_tot']}\n" s+=f"images remaining(done): {cache_text_actu[str(id)]['nb_tasks_to_do']}({cache_text_actu[str(id)]['nb_tasks_tot']-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']}\n" #s+=f"{tempo_update_actu*incr_update_actu[str(id)]} s" #incr_update_actu[str(id)]+=1 s+=f"{randint(1,MAX_SEED)}" return gr.Textbox(s) def make_me(): with gr.Tab(" "): with gr.Column(): with gr.Row(): with gr.Column(scale=4): prompt_publ=gr.Textbox(label='Your prompt:', lines=4, interactive = True) choice_model_publ=gr.Dropdown(label="List of Models", choices=list(models_publ),value=models_publ[0]) gen_button_publ = gr.Button('Generate images',scale=2) image_publ=gr.Image(None,label=models_publ[0],interactive=False) current_models_publ=gr.Textbox(models_publ[0],visible=False,show_label=False) choice_model_publ.change(load_model_publ,[choice_model_publ],[image_publ,current_models_publ]) gen_event_publ = gr.on(triggers=[gen_button_publ.click, prompt_publ.submit], fn=gen_fn, inputs=[choice_model_publ, prompt_publ], outputs=[image_publ]) with gr.Row(): with gr.Column(scale=4): test_pass=gr.Textbox(show_label=False,lines=1, interactive = True) button_test_pass=gr.Button(" ",scale=1) with gr.Tab(" Sort ",visible=False) as tab_p: button_test_pass.click(test_pass_aff,[test_pass],[tab_p]) with gr.Column(): with gr.Group(): with gr.Row(): with gr.Column(scale=4): txt_input = gr.Textbox(label='Your prompt:', lines=4, interactive = True) neg_input = gr.Textbox(label='Negative prompt:', lines=4, interactive = True) with gr.Column(scale=4): with gr.Row(): width = gr.Slider(label="Width", info="If 0, the default value is used.", maximum=2024, step=32, value=0, interactive = True) height = gr.Slider(label="Height", info="If 0, the default value is used.", maximum=2024, step=32, value=0, interactive = True) with gr.Row(): choice_ratio = gr.Dropdown(label="Ratio Width/Height", info="OverWrite Width and Height (W*H<1024*1024)", show_label=True, choices=list(list_ratios) , interactive = True, value=list_ratios[0][1]) choice_ratio.change(ratio_chosen,[choice_ratio,width,height],[width,height]) with gr.Row(): steps = gr.Slider(label="Number of inference steps", info="If 0, the default value is used.", maximum=100, step=1, value=0, interactive = True) cfg = gr.Slider(label="Guidance scale", info="If 0, the default value is used.", maximum=30.0, step=0.1, value=0, interactive = True) seed = gr.Slider(label="Seed", info="Randomize Seed if -1.", minimum=-1, maximum=MAX_SEED, step=1, value=-1, interactive = True) add_param=gr.Button("Add to the list") del_param=gr.Button("Delete to the list") #gen_button = gr.Button('Generate images', scale=3) #stop_button = gr.Button('Stop', variant='secondary', interactive=False, scale=1) #gen_button.click(lambda: gr.update(interactive=True), None, stop_button) list_param=gr.Dropdown(choices=[["a",[["","",0,0,0,0,-1]]]], value=[["","",0,0,0,0,-1]], visible=False) disp_param = gr.Examples( label="list of prompt", examples=list_param.value, inputs=[txt_input,neg_input,width,height,steps,cfg,seed], outputs=[txt_input,neg_input,width,height,steps,cfg,seed], ) with gr.Accordion("Restore Session",open=False) : with gr.Row(): text_info_session=gr.Textbox() with gr.Column(): button_info_session=gr.Button("Get infos sessions") button_info_session.click(print_info_sessions,[],[text_info_session]) id_session=gr.Number(0,interactive = True,label="ID session",show_label=True) button_restore_session=gr.Button("Restore Session") add_param.click(fonc_add_param,[list_param,txt_input,neg_input,width,height,steps,cfg,seed],[disp_param.dataset,list_param]) add_param.click(set_session,[id_session],[id_session]) del_param.click(fonc_del_param,[list_param,txt_input,neg_input,width,height,steps,cfg,seed],[disp_param.dataset,list_param]) with gr.Row(): list_models_to_gen=gr.Dropdown(choices=[["",[]]], value=[], visible=False) disp_info=gr.Textbox(label="Info") with gr.Column(): with gr.Row(): nb_images_by_prompt=gr.Number(2,label="Number of images by prompt:",interactive=True) nb_of_models_to_gen=gr.Number(10,label="Number of Models:",interactive=True) index_tag=gr.Dropdown(label="Tag",choices=list(list_tags),type="index") index_first_model=gr.Dropdown(label="First model",choices=list([]), type="index") index_tag.change(lambda i:gr.Dropdown(choices=list([f"({j+1}/{len(tags_plus_models[i][2])}) {tags_plus_models[i][2][j]}" for j in range(len(tags_plus_models[i][2]))])), index_tag,index_first_model) load_info=gr.Button("Load Models") load_info.click(fonc_load_info,[nb_of_models_to_gen,index_tag,index_first_model],[nb_of_models_to_gen,disp_info,list_models_to_gen]) button_load_random_models=gr.Button("Load Random Models") button_load_random_models.click(load_random_models,[nb_of_models_to_gen,index_tag],[nb_of_models_to_gen,disp_info,list_models_to_gen]) with gr.Accordion("Models Custom",open=False) : with gr.Row(): text_list_model_custom=gr.Textbox(label="List Models Custom") with gr.Column(): list_model_custom=gr.Dropdown(choices=[["",[]]], value=[], visible=False) #use_models_custom=gr.Radio("Use Models Custom",value=False) cut_model_custom=gr.Button("Cut Text Models Custom") cut_model_custom.click(aff_models_perso,[text_list_model_custom],[list_model_custom]) index_first_model_custom=gr.Dropdown(label="First model",choices=list([]), type="index") list_model_custom.change(lambda li:gr.Dropdown(choices=list([f"({j+1}/{len(li)}) {li[j]}" for j in range(len(li))])), [list_model_custom],index_first_model_custom) load_model_custom=gr.Button("Load Models Custom") load_model_custom.click(fonc_load_info_custom,[nb_of_models_to_gen,list_model_custom,index_first_model_custom],[nb_of_models_to_gen,disp_info,list_models_to_gen]) list_models_to_gen.change(crea_list_task,[id_session,list_param,list_models_to_gen,nb_images_by_prompt],[]) with gr.Column(): button_start=gr.Button("START") button_stop=gr.Button("STOP") cont=gr.Checkbox(True,visible=False) button_start.click(lambda:True,[],[cont]) button_stop.click(lambda:False,[],[cont]) #text_actu=gr.Textbox("",label="in progress",interactive=False,lines=6) text_actu=gr.Textbox(fonc_update_actu_2,inputs=id_session,every=tempo_update_actu,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]) #button_start.click(lambda:gr.Number(0),[],[incr_update_actu]) with gr.Accordion("Gallery Parameters",open=False) : with gr.Row(): with gr.Column(): set_height_gallery=gr.Checkbox(True,label="set height",show_label=True) height_gallery=gr.Number(650,label="height",show_label=True) col_gallery=gr.Number(5,label="nb columns",show_label=True) row_gallery=gr.Number(4,label="nb row",show_label=True) with gr.Column(): button_reset_cache_image=gr.Button("Reset Images") button_reset_cache_image.click(reset_cache_image,[id_session],[]) button_reset_cache_image_all_session=gr.Button("Reset Images ALL SESSION") button_reset_cache_image_all_session.click(reset_cache_image_all_sessions,[],[]) with gr.Row(): outputs=[] id_modules=[] states=[] for i in range(nb_req_simult): #outputs.append(gr.Image(None,interactive=False,render=False)) #id_modules.append(gr.Number(i,interactive=False,render=False)) outputs.append(gr.Image(None,interactive=False,visible=False)) id_modules.append(gr.Number(i,interactive=False,visible=False)) states.append(gr.Textbox("1",interactive=False,visible=False)) 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,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=False, container=True, format="png", preview=True, object_fit="contain",columns=5,rows=4,height=650) gallery_by_prompt = gr.Gallery(label="Output", show_download_button=True, elem_classes="gallery", interactive=False, show_share_button=False, container=True, format="png", preview=True, object_fit="contain",columns=5,rows=4,visible=False,height=650) gallery_models=[] index_gallery=[] set_height_gallery.change(lambda g,h,s: gr.Gallery(g,height=h) if s else gr.Gallery(g,height=None), [gallery,height_gallery,set_height_gallery],[gallery]) height_gallery.change(lambda g,h: gr.Gallery(g,height=h),[gallery,height_gallery],[gallery]) col_gallery.change(lambda g,h: gr.Gallery(g,columns=h),[gallery,col_gallery],[gallery]) row_gallery.change(lambda g,h: gr.Gallery(g,rows=h),[gallery,row_gallery],[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=False, container=True, format="png", preview=True, object_fit="contain",columns=5,rows=4,visible=False,height=650)) index_gallery.append(gr.Number(i,visible=False)) set_height_gallery.change(lambda g,h,s: gr.Gallery(g,height=h) if s else gr.Gallery(g,height=None), [gallery_models[i],height_gallery,set_height_gallery],[gallery_models[i]]) height_gallery.change(lambda g,h: gr.Gallery(g,height=h),[gallery_models[i],height_gallery],[gallery_models[i]]) col_gallery.change(lambda g,h: gr.Gallery(g,columns=h),[gallery_models[i],col_gallery],[gallery_models[i]]) row_gallery.change(lambda g,h: gr.Gallery(g,rows=h),[gallery_models[i],row_gallery],[gallery_models[i]]) with gr.Column(scale=3): button_load_gallery=gr.Button("Load Gallery All") button_load_gallery.click(fonc_load_gallery,[id_session,gallery],[gallery]) with gr.Accordion("Gallery by Model",open=True) : 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") 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_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_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_m],[text_fav]) with gr.Accordion("Gallery by Prompt",open=False) : index_gallery_by_prompt=gr.Number(0,visible=False) button_load_gallery_by_prompt=gr.Button("Load Gallery by prompt") text_gallery_by_prompt=gr.Textbox(f"{index_gallery_by_prompt.value+1}/{len(list_param.value)}",show_label=False) index_gallery_by_prompt.change(lambda i,p:gr.Textbox(f"{i+1}/{len(p)}"),[index_gallery_by_prompt,list_param],[text_gallery_by_prompt]) button_load_gallery_by_prompt.click(load_gallery_by_prompt, [id_session,gallery_by_prompt,index_gallery_by_prompt,list_param],[gallery_by_prompt]) gen_event_gallery_by_prompt = gr.on(triggers=[button_load_gallery_by_prompt.click], fn=lambda g:gr.Gallery(g,visible=False), inputs=[gallery], outputs=[gallery]) gen_event_gallery_first = gr.on(triggers=[button_load_gallery_first.click], fn=lambda g:gr.Gallery(g,visible=False), inputs=[gallery_by_prompt], outputs=[gallery_by_prompt]) gen_event_gallery = gr.on(triggers=[button_load_gallery.click], fn=lambda g:gr.Gallery(g,visible=False), inputs=[gallery_by_prompt], outputs=[gallery_by_prompt]) for g,i in zip(gallery_models,index_gallery): gen_event_gallery_by_prompt = gr.on(triggers=[button_load_gallery_by_prompt.click], fn=lambda g:gr.Gallery(g,visible=False), inputs=[g], outputs=[g]) with gr.Row(): button_gallery_prev_prompt=gr.Button("Prev prompt") button_gallery_next_prompt=gr.Button("Next prompt") button_gallery_next_prompt.click(lambda i,p: (i+1)%len(p),[index_gallery_by_prompt,list_param],[index_gallery_by_prompt]) button_gallery_prev_prompt.click(lambda i,p: (i-1)%len(p),[index_gallery_by_prompt,list_param],[index_gallery_by_prompt]) index_gallery_by_prompt.change(load_gallery_by_prompt, [id_session,gallery_by_prompt,index_gallery_by_prompt,list_param],[gallery_by_prompt]) set_height_gallery.change(lambda g,h,s: gr.Gallery(g,height=h) if s else gr.Gallery(g,height=None), [gallery_by_prompt,height_gallery,set_height_gallery],[gallery_by_prompt]) height_gallery.change(lambda g,h: gr.Gallery(g,height=h),[gallery_by_prompt,height_gallery],[gallery_by_prompt]) col_gallery.change(lambda g,h: gr.Gallery(g,columns=h),[gallery_by_prompt,col_gallery],[gallery_by_prompt]) row_gallery.change(lambda g,h: gr.Gallery(g,rows=h),[gallery_by_prompt,row_gallery],[gallery_by_prompt]) button_restore_session.click(fonc_restore_session,[id_session],[list_param,disp_param.dataset,list_models_to_gen,nb_of_models_to_gen]) with gr.Tab(" Warm ",visible=False) as tab_warm: button_test_pass.click(test_pass_aff,[test_pass],[tab_warm]) with gr.Column(): with gr.Group(): with gr.Row(): with gr.Column(scale=4): txt_input_w = gr.Textbox(label='Your prompt:', lines=4, interactive = True) neg_input_w = gr.Textbox(label='Negative prompt:', lines=4, interactive = True) with gr.Column(scale=4): with gr.Row(): width_w = gr.Slider(label="Width", info="If 0, the default value is used.", maximum=2024, step=32, value=0, interactive = True) height_w = gr.Slider(label="Height", info="If 0, the default value is used.", maximum=2024, step=32, value=0, interactive = True) with gr.Row(): choice_ratio_w = gr.Dropdown(label="Ratio Width/Height", info="OverWrite Width and Height (W*H<1024*1024)", show_label=True, choices=list(list_ratios) , interactive = True, value=list_ratios[0][1]) choice_ratio_w.change(ratio_chosen,[choice_ratio_w,width,height_w],[width_w,height_w]) with gr.Row(): steps_w = gr.Slider(label="Number of inference steps", info="If 0, the default value is used.", maximum=100, step=1, value=0, interactive = True) cfg_w = gr.Slider(label="Guidance scale", info="If 0, the default value is used.", maximum=30.0, step=0.1, value=0, interactive = True) seed_w = gr.Slider(label="Seed", info="Randomize Seed if -1.", minimum=-1, maximum=MAX_SEED, step=1, value=-1, interactive = True) add_param_w=gr.Button("Add to the list") del_param_w=gr.Button("Delete to the list") list_param_w=gr.Dropdown(choices=[["a",[["","",0,0,0,0,-1]]]], value=[["","",0,0,0,0,-1]], visible=False) disp_param_w = gr.Examples( label="list of prompt", examples=list_param_w.value, inputs=[txt_input_w,neg_input_w,width_w,height_w,steps_w,cfg_w,seed_w], outputs=[txt_input_w,neg_input_w,width_w,height_w,steps_w,cfg_w,seed_w], ) bool_warm=gr.Checkbox(visible=False,value=True) add_param_w.click(fonc_add_param,[list_param_w,txt_input_w,neg_input_w,width_w,height_w,steps_w,cfg_w,seed_w],[disp_param_w.dataset,list_param_w]) add_param_w.click(set_session,[id_session,bool_warm],[id_session]) del_param_w.click(fonc_del_param,[list_param_w,txt_input_w,neg_input_w,width_w,height_w,steps_w,cfg_w,seed_w],[disp_param_w.dataset,list_param_w]) with gr.Row(): nb_images_by_prompt_w=gr.Number(2,label="Images by prompt",interactive = True) nb_modules_w=gr.Slider(label="Module use", minimum=1, maximum=nb_req_simult, step=1, value=40, interactive = True) text_tag_w=gr.Textbox("",label="Tag",interactive = True,lines=1) with gr.Column(): button_load_task_w=gr.Button("LOAD") button_load_task_w.click(set_tasks_w,[id_session,list_param_w,nb_images_by_prompt_w],[]) button_start_w=gr.Button("START") button_stop_w=gr.Button("STOP") cont_w=gr.Checkbox(True,visible=False) button_start_w.click(lambda:True,[],[cont_w]) button_stop_w.click(lambda:False,[],[cont_w]) text_actu_w=gr.Textbox(fonc_update_actu_w,inputs=id_session,every=tempo_update_actu,label="in progress",interactive=False,lines=6)############ update_actu_w=gr.Number(0,visible=False) with gr.Accordion("Gallery Parameters",open=False) : with gr.Row(): with gr.Column(): set_height_gallery_w=gr.Checkbox(True,label="set height",show_label=True) height_gallery_w=gr.Number(650,label="height",show_label=True) col_gallery_w=gr.Number(5,label="nb columns",show_label=True) row_gallery_w=gr.Number(4,label="nb row",show_label=True) with gr.Column(): button_reset_cache_image_w=gr.Button("Reset Images") button_reset_cache_image_w.click(reset_cache_image,[id_session],[]) button_reset_cache_image_all_session_w=gr.Button("Reset Images ALL SESSION") button_reset_cache_image_all_session_w.click(reset_cache_image_all_sessions,[],[]) with gr.Row(): outputs_w=[] id_modules_w=[] states_w=[] for i in range(nb_req_simult): outputs_w.append(gr.Image(None,interactive=False,visible=False)) id_modules_w.append(gr.Number(i,interactive=False,visible=False)) states_w.append(gr.Textbox("1",interactive=False,visible=False)) for o,i,s in zip(outputs_w,id_modules_w,states_w): s.change(fonc_start_w,[id_session,i,s,cont_w,nb_modules_w,text_tag_w],[o,s,update_actu_w])################# gen_event = gr.on(triggers=[button_start_w.click], fn=fonc_init,inputs=[s], outputs=[s])################### with gr.Column(scale=2): gallery_w = gr.Gallery(label="Output", show_download_button=True, elem_classes="gallery", interactive=False, show_share_button=False, container=True, format="png", preview=True, object_fit="contain",columns=5,rows=4,height=650) gallery_by_prompt_w = gr.Gallery(label="Output", show_download_button=True, elem_classes="gallery", interactive=False, show_share_button=False, container=True, format="png", preview=True, object_fit="contain",columns=5,rows=4,visible=False,height=650) set_height_gallery_w.change(lambda g,h,s: gr.Gallery(g,height=h) if s else gr.Gallery(g,height=None), [gallery_w,height_gallery_w,set_height_gallery_w],[gallery_w]) height_gallery_w.change(lambda g,h: gr.Gallery(g,height=h),[gallery_w,height_gallery_w],[gallery_w]) col_gallery_w.change(lambda g,h: gr.Gallery(g,columns=h),[gallery_w,col_gallery_w],[gallery_w]) row_gallery_w.change(lambda g,h: gr.Gallery(g,rows=h),[gallery_w,row_gallery_w],[gallery_w]) set_height_gallery_w.change(lambda g,h,s: gr.Gallery(g,height=h) if s else gr.Gallery(g,height=None), [gallery_by_prompt_w,height_gallery_w,set_height_gallery_w],[gallery_by_prompt_w]) height_gallery_w.change(lambda g,h: gr.Gallery(g,height=h),[gallery_by_prompt_w,height_gallery_w],[gallery_by_prompt_w]) col_gallery_w.change(lambda g,h: gr.Gallery(g,columns=h),[gallery_by_prompt_w,col_gallery_w],[gallery_by_prompt_w]) row_gallery_w.change(lambda g,h: gr.Gallery(g,rows=h),[gallery_by_prompt_w,row_gallery_w],[gallery_by_prompt_w]) with gr.Column(scale=3): button_load_gallery_w=gr.Button("Load Gallery All") button_load_gallery_w.click(fonc_load_gallery,[id_session,gallery_w],[gallery_w]) with gr.Accordion("Gallery by Prompt",open=False) : index_gallery_by_prompt_w=gr.Number(0,visible=False) button_load_gallery_by_prompt_w=gr.Button("Load Gallery by prompt") text_gallery_by_prompt_w=gr.Textbox(f"{index_gallery_by_prompt_w.value+1}/{len(list_param_w.value)}",show_label=False) index_gallery_by_prompt_w.change(lambda i,p:gr.Textbox(f"{i+1}/{len(p)}"),[index_gallery_by_prompt_w,list_param_w],[text_gallery_by_prompt_w]) button_load_gallery_by_prompt_w.click(load_gallery_by_prompt, [id_session,gallery_by_prompt_w,index_gallery_by_prompt_w,list_param_w],[gallery_by_prompt_w]) gen_event_gallery_by_prompt_w = gr.on(triggers=[button_load_gallery_by_prompt_w.click], fn=lambda g:gr.Gallery(g,visible=False), inputs=[gallery_w], outputs=[gallery_w]) gen_event_gallery_w = gr.on(triggers=[button_load_gallery_w.click], fn=lambda g:gr.Gallery(g,visible=False), inputs=[gallery_by_prompt_w], outputs=[gallery_by_prompt_w]) with gr.Row(): button_gallery_prev_prompt_w=gr.Button("Prev prompt") button_gallery_next_prompt_w=gr.Button("Next prompt") button_gallery_next_prompt_w.click(lambda i,p: (i+1)%len(p),[index_gallery_by_prompt_w,list_param_w],[index_gallery_by_prompt_w]) button_gallery_prev_prompt_w.click(lambda i,p: (i-1)%len(p),[index_gallery_by_prompt_w,list_param_w],[index_gallery_by_prompt_w]) index_gallery_by_prompt_w.change(load_gallery_by_prompt, [id_session,gallery_by_prompt_w,index_gallery_by_prompt_w,list_param_w],[gallery_by_prompt_w]) js_code = """ console.log('ghgh'); """ with gr.Blocks(theme="Nymbo/Nymbo_Theme", fill_width=True, css="div.float.svelte-1mwvhlq { position: absolute; top: var(--block-label-margin); left: var(--block-label-margin); background: none; border: none;}") as demo: gr.Markdown("") make_me() # https://www.gradio.app/guides/setting-up-a-demo-for-maximum-performance #demo.queue(concurrency_count=999) # concurrency_count is deprecated in 4.x demo.queue(default_concurrency_limit=200, max_size=200) demo.launch(max_threads=400)