Update app.py

app.py

@@ -9,12 +9,17 @@ from datetime import datetime
 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.
-# --- Step 2: Authenticate and fetch your models
 
+
+stop_event = asyncio.Event()
 default_models = models[:howManyModelsToUse]
 api = HfApi()
 user_info = whoami(token=HF_TOKEN)
 username = user_info["name"]
+print(f"{username}")
+print(f"{username}")
+print(f"{username}")
+print(f"{username}")
 from handle_models import load_fn,infer,gen_fn
 from externalmod import gr_Interface_load, save_image, randomize_seed
 def extend_choices(choices):
@@ -37,7 +42,206 @@ load_fn(models,HF_TOKEN)
 
 
 
+
+
+
+# === CONFIG ===
+host = "api-inference.huggingface.co"
+endpoint = "/models/charliebaby2023/cybrony"
+token = HF_TOKEN 
+prompt = "a futuristic city on Mars at sunset"
+
+# === REQUEST SETUP ===
+body = json.dumps({
+    "inputs": prompt
+})
+headers = {
+    "Authorization": f"Bearer {token}",
+    "Content-Type": "application/json",
+    "User-Agent": "PythonRawClient/1.0"
+}
+
+# === CONNECTION ===
+context = ssl.create_default_context()
+conn = http.client.HTTPSConnection(host, context=context)
+
+# === RAW REQUEST ===
+print("🔸 REQUEST LINE:")
+print(f"POST {endpoint} HTTP/1.1")
+print(f"Host: {host}")
+for key, value in headers.items():
+    print(f"{key}: {value}")
+print(f"\n{body}\n")
+
+# Send request
+conn.request("POST", endpoint, body=body, headers=headers)
+
+# === RAW RESPONSE ===
+response = conn.getresponse()
+print("🔹 STATUS:", response.status, response.reason)
+print("🔹 RESPONSE HEADERS:")
+for hdr in response.getheaders():
+    print(f"{hdr[0]}: {hdr[1]}")
+print("\n🔹 RESPONSE BODY (raw):")
+raw = response.read()
+try:
+    print(raw.decode("utf-8")[:1000])  # print first 1k chars
+except UnicodeDecodeError:
+    print("[binary data]")
+
+
+
+def query_model(model_name,prompt):
+    logs = []
+    img_out = None
+
+    host = "api-inference.huggingface.co"
+    endpoint = f"/models/{model_name}"
+    # Prepare request
+    body = json.dumps({"inputs": prompt})
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "User-Agent": "PythonRawClient/1.0"
+    }
+
+    # Connect
+    context = ssl.create_default_context()
+    conn = http.client.HTTPSConnection(host, context=context)
+
+    logs.append(f"📤 POST {endpoint}")
+    logs.append(f"Headers: {headers}")
+    logs.append(f"Body: {body}\n")
+
+    try:
+        
+        conn.request("POST", endpoint, body=body, headers=headers)
+        response = conn.getresponse()
+
+        logs.append(f"📥 Status: {response.status} {response.reason}")
+        logs.append("Headers:")
+        for k, v in response.getheaders():
+            logs.append(f"{k}: {v}")
+
+        raw = response.read()
+
+        try:
+            text = raw.decode("utf-8")
+            result = json.loads(text)
+            logs.append("\nBody:\n" + text[:1000])
+        except:
+            result = raw
+            logs.append("\n⚠️ Binary response.")
+
+        # === HANDLE RESPONSE ===
+        def show(img_bytes):
+            try:
+                img = Image.open(BytesIO(img_bytes))
+                return img
+            except Exception as e:
+                logs.append(f"❌ Failed to open image: {e}")
+                return None
+
+        if isinstance(result, dict):
+            if "image" in result:
+                logs.append("🧠 Found base64 image in 'image'")
+                return show(base64.b64decode(result["image"])), "\n".join(logs)
+
+            elif "url" in result or "image_url" in result:
+                url = result.get("url") or result.get("image_url")
+                logs.append(f"🌐 Found image URL: {url}")
+                r = requests.get(url)
+                return show(r.content), "\n".join(logs)
+
+            else:
+                logs.append("⚠️ No image found in response.")
+                return None, "\n".join(logs)
+
+        elif isinstance(result, bytes):
+            logs.append("🧾 Raw image bytes returned.")
+            return show(result), "\n".join(logs)
+
+        else:
+            logs.append("❌ Unknown response format.")
+            return None, "\n".join(logs)
+
+    except Exception as e:
+        logs.append(f"💥 Exception: {e}")
+        return None, "\n".join(logs)
+
+
+# === GRADIO UI ===
+
+
+
+def query_model2(model_name, prompt):
+    logs = []
+    img_out = None
+    try:
+        model = gr.Interface.load(f"models/{model_name}", token=HF_TOKEN)
+        logs.append(f"Prompt: {prompt}")
+        response = model.predict(prompt)
+        logs.append(f"Model response: {response}")
+        def get_image_from_response(response):
+            if isinstance(response, dict):
+                if "image" in response:
+                    img_data = base64.b64decode(response["image"])
+                    img = Image.open(BytesIO(img_data))
+                    return img
+                elif "url" in response or "image_url" in response:
+                    url = response.get("url") or response.get("image_url")
+                    img_data = requests.get(url).content
+                    img = Image.open(BytesIO(img_data))
+                    return img
+            elif isinstance(response, bytes):
+                img = Image.open(BytesIO(response))
+                return img
+            return None
+        img_out = get_image_from_response(response)
+    except Exception as e:
+        logs.append(f"Error: {e}")
+        response = None
+    return img_out, "\n".join(logs)
+
+  
+
+
+
+
+
+
+def debugon():
+    print(f"DEBUGGING MODE : ON ")
+    logging.basicConfig(level=logging.DEBUG, format='%(message)s')
+    error_handler = ErrorCodeLogHandler()
+    print(f"{error_handler}")
+    logging.getLogger().addHandler(error_handler)
+def debugoff():
+    print(f"DEBUGGING MODE : OFF ")
+    logging.basicConfig(level=logging.WARNING, format='%(message)s')
+    error_handler = ErrorCodeLogHandler()
+    print(f"{error_handler}")
+    logging.getLogger().addHandler(error_handler)    
+def handle_debug_mode(selected_option):
+    if selected_option == "debug on":
+        debugon()
+    else:
+        debugoff()
+
+
+
+def stop_all_tasks():
+    print("Stopping...")
+    stop_event.set()
+
+
+
 with gr.Blocks(fill_width=True) as demo:
+   with gr.Tab(label="DEBUG"):
+    with gr.Row():
+        radio = gr.Radio(["debug on", "debug off"], value="debug off",  label="   Debug mode: activated in output log", interactive=True)
+        radio.change(handle_debug_mode, radio, None)  
+
     with gr.Tab(str(num_models) + ' Models'):
         with gr.Column(scale=2):
             with gr.Group():
@@ -65,20 +269,29 @@ with gr.Blocks(fill_width=True) as demo:
                               visible=True) for m in default_models]
                     current_models = [gr.Textbox(m, visible=False) for m in default_models]
 
+        #for m, o in zip(current_models, output):
+        #    gen_event = gr.on(triggers=[gen_button.click, txt_input.submit], fn=gen_fn,
+        #                      inputs=[m, txt_input, neg_input, height, width, steps, cfg, seed], outputs=[o],
+        #                      concurrency_limit=None, queue=False)
         for m, o in zip(current_models, output):
-            gen_event = gr.on(triggers=[gen_button.click, txt_input.submit], fn=gen_fn,
-                              inputs=[m, txt_input, neg_input, height, width, steps, cfg, seed], outputs=[o],
-                              concurrency_limit=None, queue=False)
-            
-
+            gen_button.click(        fn=gen_fn,        inputs=[m, txt_input, neg_input, height, width, steps, cfg, seed, timeout=120],        outputs=[o],queue=False)
+            #concurrency_limit=None,
+            txt_input.submit(        fn=gen_fn,        inputs=[m, txt_input, neg_input, height, width, steps, cfg, seed, timeout=120],        outputs=[o],queue=False)
+    
         with gr.Column(scale=4):
             with gr.Accordion('Model selection'):
                 model_choice = gr.CheckboxGroup(models, label = f'Choose up to {int(num_models)} different models from the {len(models)} available!', value=models, interactive=True)
                 model_choice.change(update_imgbox, model_choice, output)
                 model_choice.change(extend_choices, model_choice, current_models)
                 random_button.click(random_choices, None, model_choice)
-
-demo.launch(show_api=False, max_threads=400)
+        stop_button = gr.Button("Stop 🛑", variant="stop")
+        stop_button.click(
+            fn=stop_all_tasks,
+            inputs=[],
+            outputs=[]
+        )        
+
+demo.launch(show_api=True, max_threads=400)
 
 
 '''