Upload folder using huggingface_hub

README.md

@@ -1,6 +1,6 @@
 ---
 title: Bridge Forge Environment Server
-emoji: 🌉
+emoji: "\U0001F309"
 colorFrom: blue
 colorTo: green
 sdk: docker

server/app.py

@@ -16,9 +16,11 @@ except Exception as e:
 try:
     from ..models import BridgeForgeAction, BridgeForgeObservation
     from .bridge_forge_environment import BridgeForgeEnvironment
+    from .gradio_app import build_bridge_forge_ui
 except (ImportError, ValueError):
     from models import BridgeForgeAction, BridgeForgeObservation
     from server.bridge_forge_environment import BridgeForgeEnvironment
+    from server.gradio_app import build_bridge_forge_ui
 
 app = create_app(
     BridgeForgeEnvironment,
@@ -26,6 +28,7 @@ app = create_app(
     BridgeForgeObservation,
     env_name="bridge_forge",
     max_concurrent_envs=4,
+    gradio_builder=build_bridge_forge_ui,
 )
 
 STATIC_DIR = "/tmp/bridge_forge_static"

server/gradio_app.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+import gradio as gr
+
+PARAM_EXAMPLES = {
+    "select_type": '{"bridge_type": "warren_truss"}',
+    "add_node": '{"node_id": "n1", "x": 0.0, "y": 0.0}',
+    "add_member": '{"member_id": "m1", "node_start": "n1", "node_end": "n2", "material": "steel", "section_area": 0.01}',
+    "add_support": '{"node_id": "n1", "support_type": "pin"}',
+    "add_load": '{"node_id": "n2", "Fx": 0.0, "Fy": -50.0}',
+    "simulate": "{}",
+    "submit": "{}",
+}
+
+ACTION_TYPES = list(PARAM_EXAMPLES.keys())
+
+SCENARIO_IDS = ["easy", "medium", "hard"]
+
+
+def _format_obs(data: Dict[str, Any]) -> str:
+    obs = data.get("observation", {})
+    lines: List[str] = []
+
+    if obs.get("message"):
+        lines.append(f"**Message:** {obs['message']}")
+    if obs.get("scenario"):
+        lines.append(f"\n**Scenario:** {obs['scenario'][:200]}...")
+    if obs.get("bridge_type"):
+        lines.append(f"**Bridge type:** `{obs['bridge_type']}`")
+    if obs.get("constraints"):
+        lines.append(f"**Constraints:** `{obs['constraints']}`")
+
+    nodes = obs.get("nodes", [])
+    members = obs.get("members", [])
+    supports = obs.get("supports", [])
+    loads = obs.get("loads", [])
+    if nodes:
+        lines.append(f"\n**Nodes ({len(nodes)}):** {', '.join(n.get('node_id','?') for n in nodes)}")
+    if members:
+        lines.append(f"**Members ({len(members)}):** {', '.join(m.get('member_id','?') for m in members)}")
+    if supports:
+        lines.append(f"**Supports ({len(supports)}):** {', '.join(s.get('node_id','?')+' ('+s.get('support_type','?')+')' for s in supports)}")
+    if loads:
+        lines.append(f"**Loads ({len(loads)}):** {', '.join(l.get('node_id','?') for l in loads)}")
+
+    sim = obs.get("simulation_result")
+    if sim:
+        lines.append("\n### Simulation Results")
+        lines.append(f"- **Status:** `{sim.get('structural_status', '?')}`")
+        lines.append(f"- **Max deflection:** `{sim.get('max_deflection_mm', 0):.4f} mm`")
+        lines.append(f"- **Max stress ratio:** `{sim.get('max_stress_ratio', 0):.4f}`")
+        lines.append(f"- **Total mass:** `{sim.get('total_mass_kg', 0):.2f} kg`")
+        lines.append(f"- **Cost:** `{sim.get('cost_inr', 0):,.0f} INR`")
+        lines.append(f"- **Members:** `{sim.get('member_count', 0)}`")
+        if sim.get("failed_members"):
+            lines.append(f"- **Failed:** `{sim['failed_members']}`")
+
+    reward = data.get("reward")
+    done = data.get("done")
+    if reward is not None:
+        lines.append(f"\n**Reward:** `{reward}`")
+    if done is not None:
+        lines.append(f"**Done:** `{done}`")
+
+    return "\n".join(lines) if lines else "*No observation data*"
+
+
+def _get_viz_url(data: Dict[str, Any]) -> Optional[str]:
+    sim = data.get("observation", {}).get("simulation_result")
+    if sim and sim.get("visualization_url"):
+        return sim["visualization_url"]
+    return None
+
+
+def build_bridge_forge_ui(
+    web_manager: Any,
+    action_fields: List[Dict[str, Any]],
+    metadata: Any,
+    is_chat_env: bool,
+    title: str,
+    quick_start_md: Optional[str],
+) -> gr.Blocks:
+    async def reset_env(scenario_id: str):
+        try:
+            data = await web_manager.reset_environment(
+                {"scenario_id": scenario_id or "easy"}
+            )
+            obs_md = _format_obs(data)
+            return (
+                obs_md,
+                json.dumps(data, indent=2),
+                f"Reset with scenario: {scenario_id}",
+                None,
+            )
+        except Exception as e:
+            return ("", "", f"Error: {e}", None)
+
+    async def step_env(action_type: str, params_json: str):
+        if not action_type:
+            return ("", "", "Select an action type first.", None)
+        try:
+            params = json.loads(params_json) if params_json.strip() else {}
+        except json.JSONDecodeError as e:
+            return ("", "", f"Invalid JSON in params: {e}", None)
+
+        action_data = {"action_type": action_type, "params": params}
+        try:
+            data = await web_manager.step_environment(action_data)
+            obs_md = _format_obs(data)
+            viz_url = _get_viz_url(data)
+            viz_img = None
+            if viz_url:
+                import os
+                local_path = os.path.join("/tmp/bridge_forge_static", os.path.basename(viz_url))
+                if os.path.exists(local_path):
+                    viz_img = local_path
+            return (
+                obs_md,
+                json.dumps(data, indent=2),
+                "Step complete.",
+                viz_img,
+            )
+        except Exception as e:
+            return ("", "", f"Error: {e}", None)
+
+    def update_placeholder(action_type: str):
+        return gr.update(value=PARAM_EXAMPLES.get(action_type, "{}"))
+
+    with gr.Blocks(title=f"BridgeForge: {title}") as demo:
+        gr.Markdown("## BridgeForge Playground")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                scenario_dd = gr.Dropdown(
+                    choices=SCENARIO_IDS,
+                    value="easy",
+                    label="Scenario",
+                )
+                reset_btn = gr.Button("Reset", variant="secondary")
+
+                gr.Markdown("---")
+
+                action_dd = gr.Dropdown(
+                    choices=ACTION_TYPES,
+                    value="select_type",
+                    label="Action Type",
+                )
+                params_box = gr.Textbox(
+                    label="Params (JSON)",
+                    value=PARAM_EXAMPLES["select_type"],
+                    lines=3,
+                    placeholder='e.g. {"bridge_type": "warren_truss"}',
+                )
+                step_btn = gr.Button("Step", variant="primary")
+
+                status_box = gr.Textbox(label="Status", interactive=False)
+
+            with gr.Column(scale=2):
+                obs_display = gr.Markdown(
+                    value="Click **Reset** to start a new episode."
+                )
+                viz_image = gr.Image(
+                    label="Bridge Visualization",
+                    type="filepath",
+                    interactive=False,
+                )
+                with gr.Accordion("Raw JSON", open=False):
+                    raw_json = gr.Code(
+                        label="Response",
+                        language="json",
+                        interactive=False,
+                    )
+
+        action_dd.change(
+            fn=update_placeholder,
+            inputs=[action_dd],
+            outputs=[params_box],
+        )
+
+        reset_btn.click(
+            fn=reset_env,
+            inputs=[scenario_dd],
+            outputs=[obs_display, raw_json, status_box, viz_image],
+        )
+
+        step_btn.click(
+            fn=step_env,
+            inputs=[action_dd, params_box],
+            outputs=[obs_display, raw_json, status_box, viz_image],
+        )
+
+    return demo