Upload app.py

app.py

@@ -6,24 +6,36 @@ import chess
 import chess.svg
 import chess.engine
 
-# -------- Engine binary detection --------
-def find_stockfish() -> str | None:
-    # 1) Environment variable
+# ---------- Engine discovery ----------
+def detect_stockfish_candidates():
+    cands = []
+    # env var
     env = os.environ.get("STOCKFISH_PATH")
-    if env and os.path.isfile(env) and os.access(env, os.X_OK):
-        return env
-    # 2) PATH lookup
+    if env:
+        cands.append(env)
+    # PATH
     which = shutil.which("stockfish")
     if which:
-        return which
-    # 3) Common locations on Debian/Ubuntu images
-    for p in ("/usr/bin/stockfish", "/usr/games/stockfish", "/bin/stockfish", "/opt/conda/bin/stockfish"):
+        cands.append(which)
+    # common paths
+    cands += ["/usr/bin/stockfish", "/usr/games/stockfish", "/bin/stockfish", "/opt/conda/bin/stockfish"]
+    # de-dup while preserving order
+    seen = set(); uniq = []
+    for p in cands:
+        if p and p not in seen:
+            uniq.append(p); seen.add(p)
+    return uniq
+
+def choose_stockfish_path(manual_path: str | None = None):
+    """Pick first executable path from manual path or detected candidates."""
+    if manual_path:
+        if os.path.isfile(manual_path) and os.access(manual_path, os.X_OK):
+            return manual_path
+    for p in detect_stockfish_candidates():
         if os.path.isfile(p) and os.access(p, os.X_OK):
             return p
     return None
 
-STOCKFISH_PATH = find_stockfish()
-
 DEFAULT_THREADS = max(1, os.cpu_count() or 2)
 DEFAULT_HASH_MB = 512
 DEFAULT_MOVETIME_MS = 1500
@@ -37,14 +49,12 @@ def board_svg(board: chess.Board, last_move=None) -> str:
         size=520,
     )
 
-def new_engine(threads=DEFAULT_THREADS, hash_mb=DEFAULT_HASH_MB, ponder=False):
-    if STOCKFISH_PATH is None:
-        raise FileNotFoundError(
-            "Stockfish niet gevonden. Voeg een 'apt.txt' toe met de regel 'stockfish' of "
-            "stel een omgevingsvariabele STOCKFISH_PATH in naar de binary. "
-            "Controleer ook dat de Space herbouwd is na het toevoegen van apt.txt."
-        )
-    engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
+def new_engine(path: str, threads=DEFAULT_THREADS, hash_mb=DEFAULT_HASH_MB, ponder=False):
+    if not path:
+        raise FileNotFoundError("Geen Stockfish-pad opgegeven.")
+    if not (os.path.isfile(path) and os.access(path, os.X_OK)):
+        raise FileNotFoundError(f"Stockfish niet uitvoerbaar op pad: {path}")
+    engine = chess.engine.SimpleEngine.popen_uci(path)
     opts = {
         "Threads": int(threads),
         "Hash": int(hash_mb),
@@ -59,9 +69,17 @@ def new_engine(threads=DEFAULT_THREADS, hash_mb=DEFAULT_HASH_MB, ponder=False):
         print("UCI-opties zetten gaf een fout (doorgaan):", e)
     return engine
 
-def init_state(engine_color: str, movetime_ms: int, depth: int | None, threads: int, hash_mb: int):
+def init_state(engine_color: str, movetime_ms: int, depth: int | None, threads: int, hash_mb: int, engine_path: str | None):
     board = chess.Board()
-    engine = new_engine(threads=threads, hash_mb=hash_mb)
+    # Probeer engine te starten, maar laat UI werken zonder crash
+    engine = None
+    picked = choose_stockfish_path(engine_path)
+    error = None
+    if picked:
+        try:
+            engine = new_engine(picked, threads=threads, hash_mb=hash_mb)
+        except Exception as e:
+            error = str(e)
     state = {
         "board": board,
         "engine": engine,
@@ -69,8 +87,11 @@ def init_state(engine_color: str, movetime_ms: int, depth: int | None, threads:
         "movetime_ms": movetime_ms,
         "depth": depth if depth and depth > 0 else None,
         "last_move": None,
+        "engine_path": picked or (engine_path or ""),
+        "engine_error": error,
     }
-    if engine_color == "white":
+    # Alleen automatisch zetten als engine beschikbaar is én engine wit is
+    if state["engine"] is not None and engine_color == "white":
         _ = engine_move(state)
     return state
 
@@ -83,26 +104,58 @@ def render(state):
     svg = board_svg(state["board"], last_move=state["last_move"])
     return svg, state["board"].fen()
 
-def new_game(engine_color, movetime_ms, depth, threads, hash_mb):
-    try:
-        state = init_state(engine_color, int(movetime_ms), int(depth) if depth else None, int(threads), int(hash_mb))
-        img, fen = render(state)
-        msg = f"Nieuwe partij gestart. Engine pad: {STOCKFISH_PATH or 'NIET GEVONDEN'}"
-        return state, img, fen, msg
-    except FileNotFoundError as e:
-        dummy_state = {"board": chess.Board(), "engine": None, "engine_color": engine_color, "movetime_ms": movetime_ms, "depth": depth, "last_move": None}
-        svg = board_svg(dummy_state["board"])
-        details = (
-            f"❌ {e}\n\n"
-            "Troubleshooting:\n"
-            "• Controleer dat je Space type 'Gradio' is met apt-ondersteuning.\n"
-            "• Voeg een bestand 'apt.txt' toe met exact deze inhoud:\n"
-            "  stockfish\n"
-            "• Herstart/Herbouw de Space na uploaden.\n"
-            "• Of stel een omgevingvariabele STOCKFISH_PATH in naar de binary.\n"
-            "• Probeer handmatig: /usr/bin/stockfish of /usr/games/stockfish."
+# --------- Actions ---------
+def new_game(engine_color, movetime_ms, depth, threads, hash_mb, engine_path):
+    state = init_state(engine_color, int(movetime_ms), int(depth) if depth else None, int(threads), int(hash_mb), engine_path.strip() or None)
+    img, fen = render(state)
+    if state["engine"]:
+        msg = f"Nieuwe partij gestart. Engine pad: {state['engine_path']}"
+    else:
+        diag = diagnostics()  # show where we looked
+        msg = (
+            "Nieuwe partij gestart ZONDER engine. "
+            "Vul het correcte pad in en klik 'Herstart engine'.\n\n"
+            + diag
         )
-        return dummy_state, svg, dummy_state["board"].fen(), details
+    return state, img, fen, msg, state["engine_path"]
+
+def diagnostics():
+    lines = ["🔎 Stockfish-detectie:"]
+    for p in detect_stockfish_candidates():
+        ok = "✅" if os.path.isfile(p) and os.access(p, os.X_OK) else "❌"
+        lines.append(f"{ok} {p}")
+    env = os.environ.get("STOCKFISH_PATH")
+    if env:
+        lines.append(f"Env STOCKFISH_PATH={env}")
+    lines.append("\nTip: zorg dat je in de Space een bestand 'apt.txt' hebt met:\nstockfish\n"
+                 "en rebuild de Space. Of zet Settings → Variables → STOCKFISH_PATH naar bv. /usr/games/stockfish.")
+    return "\n".join(lines)
+
+def restart_engine(state, threads, hash_mb, engine_path):
+    # sluit oude engine
+    try:
+        if state.get("engine"):
+            state["engine"].quit()
+    except Exception:
+        pass
+    # start nieuwe
+    picked = choose_stockfish_path(engine_path.strip() or None)
+    if not picked:
+        state["engine"] = None
+        state["engine_error"] = "Geen uitvoerbare Stockfish gevonden."
+        msg = "❌ Geen engine gevonden.\n" + diagnostics()
+    else:
+        try:
+            state["engine"] = new_engine(picked, threads=int(threads), hash_mb=int(hash_mb))
+            state["engine_error"] = None
+            state["engine_path"] = picked
+            msg = f"✅ Engine gestart op: {picked}"
+        except Exception as e:
+            state["engine"] = None
+            state["engine_error"] = str(e)
+            msg = f"❌ Engine-fout: {e}\n" + diagnostics()
+    img, fen = render(state)
+    return state, img, fen, msg, state.get("engine_path","")
 
 def make_move(state, user_move):
     board: chess.Board = state["board"]
@@ -124,7 +177,10 @@ def make_move(state, user_move):
 
     side_to_move = "white" if board.turn == chess.WHITE else "black"
     if side_to_move == state["engine_color"]:
-        msg = engine_move(state)
+        if state["engine"] is None:
+            msg = "Engine niet beschikbaar — vul 'Engine pad' in en klik 'Herstart engine'."
+        else:
+            msg = engine_move(state)
     else:
         msg = "Jij bent aan zet."
     img, fen = render(state)
@@ -134,7 +190,7 @@ def engine_move(state):
     board: chess.Board = state["board"]
     engine: chess.engine.SimpleEngine = state["engine"]
     if engine is None:
-        return "Engine niet beschikbaar (Stockfish niet gevonden)."
+        return "Engine niet beschikbaar."
     if board.is_game_over():
         return f"Partij afgelopen: {board.result()}."
     try:
@@ -153,6 +209,7 @@ def undo_move(state):
     if len(board.move_stack) == 0:
         return state, *render(state), "Geen zetten om terug te nemen."
     board.pop()
+    # Neem er eentje extra terug als engine aan zet zou komen
     if state["engine_color"] == ("white" if board.turn == chess.WHITE else "black") and len(board.move_stack) > 0:
         board.pop()
     state["last_move"] = board.move_stack[-1] if board.move_stack else None
@@ -163,14 +220,7 @@ def resign(state):
     outcome = "1-0" if board.turn == chess.BLACK else "0-1"
     return state, *render(state), f"Opgegeven. Resultaat: {outcome}"
 
-def stop_engine(state):
-    try:
-        if state.get("engine"):
-            state["engine"].quit()
-    except Exception:
-        pass
-    return "Engine gestopt."
-
+# ---------- UI ----------
 CSS = """
 #board { display: flex; justify-content: center; }
 #board svg { max-width: 100%; height: auto; }
@@ -197,18 +247,24 @@ with gr.Blocks(title="Boss Chess (Stockfish)", css=CSS) as demo:
         depth = gr.Slider(0, 30, value=0, step=1, label="Max diepte (0=uit)")
         threads = gr.Slider(1, DEFAULT_THREADS, value=DEFAULT_THREADS, step=1, label="Threads")
         hash_mb = gr.Slider(64, 2048, value=DEFAULT_HASH_MB, step=64, label="Hash (MB)")
+        engine_path = gr.Textbox(label="Engine pad (optioneel, bv. /usr/games/stockfish)", placeholder="/usr/games/stockfish", value="")
         btn_new = gr.Button("Nieuwe partij / herstart")
+        btn_restart = gr.Button("Herstart engine")
 
     state = gr.State()
 
-    btn_new.click(new_game, [engine_color, movetime, depth, threads, hash_mb],
-                  [state, board_html, fen_out, status])
+    # Bindings
+    btn_new.click(new_game, [engine_color, movetime, depth, threads, hash_mb, engine_path],
+                  [state, board_html, fen_out, status, engine_path])
+    btn_restart.click(restart_engine, [state, threads, hash_mb, engine_path],
+                      [state, board_html, fen_out, status, engine_path])
     btn_move.click(make_move, [state, user_move], [state, board_html, fen_out, status])
     btn_undo.click(undo_move, [state], [state, board_html, fen_out, status])
-    btn_resign.click(resign, [state], [board_html, fen_out, status])
+    btn_resign.click(resign, [state], [state, board_html, fen_out, status])
 
-    demo.load(new_game, [engine_color, movetime, depth, threads, hash_mb],
-              [state, board_html, fen_out, status])
+    # Auto-start
+    demo.load(new_game, [engine_color, movetime, depth, threads, hash_mb, engine_path],
+              [state, board_html, fen_out, status, engine_path])
 
 if __name__ == "__main__":
     demo.launch()