no JSON gradio component

app.py

@@ -1,5 +1,3 @@
-# app.py
-import json
 import logging
 import os
 import sys
@@ -9,9 +7,6 @@ import uuid
 import gradio as gr
 from daggr import FnNode, Graph
 
-# -------------------------
-# Logging (stable, no decorators)
-# -------------------------
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
@@ -20,15 +15,6 @@ logging.basicConfig(
 log = logging.getLogger("daggr.micro")
 
 
-def safe(obj, limit=1500):
-    """Dump compact et tolérant (évite que les logs explosent)."""
-    try:
-        s = json.dumps(obj, default=str, ensure_ascii=False)
-    except Exception:
-        s = f"<unserializable {type(obj).__name__}>"
-    return s if len(s) <= limit else s[:limit] + "…(truncated)"
-
-
 def make_d(seed_d: int, salt_d: int) -> tuple[int, str]:
     run_id = uuid.uuid4().hex[:8]
     t0 = time.time()
@@ -39,7 +25,7 @@ def make_d(seed_d: int, salt_d: int) -> tuple[int, str]:
     out = (val, tag)
 
     dt = (time.time() - t0) * 1000
-    log.info("[D] done  run=%s dt=%.1fms out=%s", run_id, dt, safe(out))
+    log.info("[D] done  run=%s dt=%.1fms out=%s", run_id, dt, out)
     return out
 
 
@@ -53,73 +39,56 @@ def make_e(seed_e: int, salt_e: int) -> tuple[int, str]:
     out = (val, tag)
 
     dt = (time.time() - t0) * 1000
-    log.info("[E] done  run=%s dt=%.1fms out=%s", run_id, dt, safe(out))
+    log.info("[E] done  run=%s dt=%.1fms out=%s", run_id, dt, out)
     return out
 
 
-def combine(d_val: int, d_tag: str, e_val: int, e_tag: str, alpha: float) -> tuple[dict, str]:
+def combine(d_val: int, d_tag: str, e_val: int, e_tag: str, alpha: float) -> tuple[int, str]:
     run_id = uuid.uuid4().hex[:8]
     t0 = time.time()
-    log.info(
-        "[A] start run=%s d_val=%s d_tag=%s e_val=%s e_tag=%s alpha=%s",
-        run_id, d_val, d_tag, e_val, e_tag, alpha,
-    )
-
-    # Rendre alpha robuste (spaces/gradio peut renvoyer float/str)
     a = float(alpha)
-    out = {
-        "d": {"val": int(d_val), "tag": str(d_tag)},
-        "e": {"val": int(e_val), "tag": str(e_tag)},
-        "alpha": a,
-        "mix": int((int(d_val) * a) + (int(e_val) * (1.0 - a))),
-    }
-    summary = f"mix={out['mix']} | {d_tag} + {e_tag} | alpha={a:.2f}"
-    res = (out, summary)
+    log.info("[A] start run=%s d=%s e=%s alpha=%s", run_id, (d_val, d_tag), (e_val, e_tag), a)
+
+    mix = int((int(d_val) * a) + (int(e_val) * (1.0 - a)))
+    summary = f"mix={mix} | {d_tag} + {e_tag} | alpha={a:.2f}"
 
     dt = (time.time() - t0) * 1000
-    log.info("[A] done  run=%s dt=%.1fms out=%s", run_id, dt, safe(res))
-    return res
+    log.info("[A] done  run=%s dt=%.1fms mix=%s", run_id, dt, mix)
+    return mix, summary
 
 
-def postprocess(a_json: dict, mode: str, bump: int) -> tuple[str, dict]:
+def postprocess(mix: int, a_summary: str, mode: str, bump: int) -> str:
     run_id = uuid.uuid4().hex[:8]
     t0 = time.time()
-    log.info("[B] start run=%s mode=%s bump=%s a_json=%s", run_id, mode, bump, safe(a_json))
-
-    mix = int((a_json or {}).get("mix", 0))
     bump_i = int(bump)
+    log.info("[B] start run=%s mode=%s bump=%s mix=%s", run_id, mode, bump_i, mix)
 
     if mode == "add":
-        mix2 = mix + bump_i
+        mix2 = int(mix) + bump_i
     elif mode == "mul":
-        mix2 = mix * max(1, bump_i)
+        mix2 = int(mix) * max(1, bump_i)
     else:
-        mix2 = mix
+        mix2 = int(mix)
 
-    text = f"B({mode},{bump_i}) => {mix2} (from mix={mix})"
-    out = {"mode": str(mode), "bump": bump_i, "mix_in": mix, "mix_out": mix2}
-    res = (text, out)
+    text = f"{a_summary} || B({mode},{bump_i}) => {mix2}"
 
     dt = (time.time() - t0) * 1000
-    log.info("[B] done  run=%s dt=%.1fms out=%s", run_id, dt, safe(res))
-    return res
+    log.info("[B] done  run=%s dt=%.1fms mix_out=%s", run_id, dt, mix2)
+    return text
 
 
-def observe(b_json: dict, note: str) -> str:
+def observe(b_text: str, note: str) -> str:
     run_id = uuid.uuid4().hex[:8]
     t0 = time.time()
-    log.info("[C] start run=%s note=%s b_json=%s", run_id, note, safe(b_json))
+    log.info("[C] start run=%s note=%s", run_id, note)
 
-    out = f"[C] note={note} | b={b_json}"
+    out = f"[C] note={note} | {b_text}"
 
     dt = (time.time() - t0) * 1000
-    log.info("[C] done  run=%s dt=%.1fms out=%s", run_id, dt, safe(out))
+    log.info("[C] done  run=%s dt=%.1fms", run_id, dt)
     return out
 
 
-# -------------------------
-# Node graph (D/E -> A -> B -> C)
-# -------------------------
 D = FnNode(
     fn=make_d,
     inputs={
@@ -147,16 +116,14 @@ E = FnNode(
 A = FnNode(
     fn=combine,
     inputs={
-        # Multi-upstream (port refs)
         "d_val": D.d_val,
         "d_tag": D.d_tag,
         "e_val": E.e_val,
         "e_tag": E.e_tag,
-        # UI input (forces input snapshot values)
         "alpha": gr.Slider(label="A alpha", minimum=0.0, maximum=1.0, step=0.05, value=0.5),
     },
     outputs={
-        "a_json": gr.JSON(label="A json"),
+        "mix": gr.Number(label="A mix"),
         "a_summary": gr.Textbox(label="A summary"),
     },
 )
@@ -164,41 +131,24 @@ A = FnNode(
 B = FnNode(
     fn=postprocess,
     inputs={
-        "a_json": A.a_json,
-        # UI inputs independent from D/E (good for snapshot stress)
+        "mix": A.mix,
+        "a_summary": A.a_summary,
         "mode": gr.Radio(label="B mode", choices=["none", "add", "mul"], value="none"),
         "bump": gr.Slider(label="B bump", minimum=0, maximum=5, step=1, value=1),
     },
-    outputs={
-        "b_text": gr.Textbox(label="B text"),
-        "b_json": gr.JSON(label="B json"),
-    },
+    outputs={"b_text": gr.Textbox(label="B text")},
 )
 
 C = FnNode(
     fn=observe,
     inputs={
-        "b_json": B.b_json,
+        "b_text": B.b_text,
         "note": gr.Textbox(label="C note", value="hello"),
     },
     outputs={"c_text": gr.Textbox(label="C text")},
 )
 
-graph = Graph(
-    name="micro-restore-debug",
-    nodes=[D, E, A, B, C],
-)
+graph = Graph(name="micro-restore-debug-nojson", nodes=[D, E, A, B, C])
 
-# -------------------------
-# Launch (HF Spaces friendly)
-# -------------------------
-# Spaces fournit souvent PORT
 port = int(os.getenv("PORT", "7860"))
-
-graph.launch(
-    host="0.0.0.0",
-    port=port,
-    open_browser=False,
-    log_level="debug",
-    access_log=True,
-)
+graph.launch(host="0.0.0.0", port=port, open_browser=False, log_level="debug", access_log=True)