Upload folder using huggingface_hub

Dockerfile

@@ -5,11 +5,12 @@ FROM python:3.11-slim
 WORKDIR /app
 
 # Install requirements
-RUN pip install --no-cache-dir fastapi>=0.104.0 uvicorn>=0.24.0 pydantic>=2.0.0 requests>=2.25.0
+RUN pip install --no-cache-dir fastapi>=0.104.0 uvicorn>=0.24.0 pydantic>=2.0.0 requests>=2.25.0 gradio>=4.0.0
 
-# Copy the standalone app
+# Copy the standalone app and Gradio UI
 # When deployed to HF, the Dockerfile is moved to root, so server/ contains the app
 COPY server/standalone_app.py /app/standalone_app.py
+COPY server/gradio_ui.py /app/gradio_ui.py
 
 # Expose port 8000
 EXPOSE 8000

server/gradio_ui.py

@@ -0,0 +1,255 @@
+"""
+Gradio Web Interface for Number Guessing Game Environment
+
+This module provides an interactive web UI for the number guessing game
+that can be accessed at the /web endpoint when deployed.
+"""
+
+import gradio as gr
+from typing import Tuple, List
+import random
+
+# Import the environment
+from standalone_app import NumberGuessEnvironment, GuessAction
+
+# Global environment instance for the web UI
+web_env = NumberGuessEnvironment()
+
+
+def reset_game() -> Tuple[str, str, str, str, str, List]:
+    """Reset the game and return initial UI state"""
+    obs = web_env.reset()
+
+    welcome_msg = f"""
+    # 🎯 Number Guessing Game
+
+    **{obs.hint}**
+
+    I'm thinking of a number between 1 and 100.
+    Can you guess it in {obs.attempts_remaining} attempts or less?
+
+    Strategy tip: Try binary search for optimal performance! 🧠
+    """
+
+    status = f"🎮 **Game Status:** New Game Started!"
+    attempts = f"📊 **Attempts Remaining:** {obs.attempts_remaining}"
+    reward_display = f"🎁 **Current Reward:** {obs.reward}"
+    hint_display = "💡 **Last Hint:** None yet - Make your first guess!"
+    history = []
+
+    return welcome_msg, status, attempts, reward_display, hint_display, history
+
+
+def make_guess(guess_input: str, history: List) -> Tuple[str, str, str, str, str, List, str]:
+    """Process a guess and return updated UI state"""
+
+    # Validate input
+    if not guess_input or not guess_input.strip():
+        return (
+            None,
+            "⚠️ **Status:** Please enter a number!",
+            None, None, None, history, ""
+        )
+
+    try:
+        guess = int(guess_input.strip())
+    except ValueError:
+        return (
+            None,
+            "⚠️ **Status:** Invalid input! Please enter a number between 1 and 100.",
+            None, None, None, history, ""
+        )
+
+    # Make the guess
+    action = GuessAction(guess=guess)
+    obs = web_env.step(action)
+
+    # Update history
+    history = history or []
+    history.append({
+        "Guess #": len(history) + 1,
+        "Your Guess": guess,
+        "Hint": obs.hint,
+        "Reward": f"{obs.reward:+.1f}"
+    })
+
+    # Format status message
+    if obs.hint == "correct":
+        status = f"🎉 **Congratulations!** You found the number {guess} in {len(history)} attempts!"
+        hint_display = "✨ **Last Hint:** 🎯 CORRECT! You won!"
+    elif obs.hint == "game over":
+        secret = obs.metadata.get('secret_number', '?')
+        status = f"😢 **Game Over!** The number was {secret}. Try again!"
+        hint_display = f"❌ **Last Hint:** Out of attempts. The answer was {secret}."
+    elif obs.hint.startswith("invalid"):
+        status = "⚠️ **Invalid Guess!** Number must be between 1 and 100."
+        hint_display = f"⚠️ **Last Hint:** {obs.hint}"
+    elif obs.hint == "higher":
+        status = f"📈 The number is **HIGHER** than {guess}"
+        hint_display = f"⬆️ **Last Hint:** Go HIGHER than {guess}"
+    elif obs.hint == "lower":
+        status = f"📉 The number is **LOWER** than {guess}"
+        hint_display = f"⬇️ **Last Hint:** Go LOWER than {guess}"
+    else:
+        status = f"🤔 Hint: {obs.hint}"
+        hint_display = f"💡 **Last Hint:** {obs.hint}"
+
+    # Update other displays
+    attempts = f"📊 **Attempts Remaining:** {obs.attempts_remaining}"
+    reward_display = f"🎁 **Total Reward:** {sum(float(h['Reward']) for h in history):.1f}"
+
+    # Additional context
+    welcome_msg = None  # Don't update welcome
+
+    # Clear input for next guess
+    next_input = ""
+
+    return welcome_msg, status, attempts, reward_display, hint_display, history, next_input
+
+
+def create_gradio_interface() -> gr.Blocks:
+    """Create the Gradio interface"""
+
+    with gr.Blocks(theme=gr.themes.Soft(), title="🎯 Number Guessing Game") as demo:
+
+        gr.Markdown(
+            """
+            # 🎯 Number Guessing Game Environment
+
+            Welcome to the **OpenEnv Number Guessing Game**! Test your reasoning skills by guessing
+            a secret number between 1 and 100. You'll get hints after each guess to help you narrow
+            down the answer.
+
+            **Perfect for:**
+            - 🤖 Training RL agents with binary search strategies
+            - 🧠 Testing reasoning and planning algorithms
+            - 📚 Learning reinforcement learning concepts
+            - 🎮 Having fun!
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Welcome and instructions
+                welcome = gr.Markdown(value=reset_game()[0])
+
+                # Input area
+                with gr.Row():
+                    guess_input = gr.Textbox(
+                        label="Your Guess",
+                        placeholder="Enter a number between 1 and 100...",
+                        scale=3
+                    )
+                    guess_btn = gr.Button("🎯 Guess", variant="primary", scale=1)
+
+                # Action buttons
+                with gr.Row():
+                    reset_btn = gr.Button("🔄 New Game", variant="secondary")
+
+                # Status displays
+                status = gr.Markdown(value="🎮 **Game Status:** Ready to start!")
+                hint_display = gr.Markdown(value="💡 **Last Hint:** None yet")
+
+                with gr.Row():
+                    attempts = gr.Markdown(value="📊 **Attempts Remaining:** 10")
+                    reward_display = gr.Markdown(value="🎁 **Current Reward:** 0.0")
+
+            with gr.Column(scale=1):
+                gr.Markdown("### 📊 Statistics")
+
+                # Guess history table
+                history_table = gr.Dataframe(
+                    headers=["Guess #", "Your Guess", "Hint", "Reward"],
+                    datatype=["number", "number", "str", "str"],
+                    label="Guess History",
+                    interactive=False,
+                    height=400
+                )
+
+        # Tips section
+        with gr.Accordion("💡 Strategy Tips", open=False):
+            gr.Markdown(
+                """
+                ### Optimal Strategy: Binary Search
+
+                1. **Start at 50** (middle of 1-100)
+                2. **If "higher":** Search in range [51, 100]
+                3. **If "lower":** Search in range [1, 49]
+                4. **Repeat:** Always guess the middle of your current range
+
+                This guarantees finding the number in **at most 7 guesses**! 🎯
+
+                ### Reward System
+                - ✅ **+10.0** - Correct guess (win!)
+                - ➕ **+0.1** - Valid guess (narrowing down)
+                - ❌ **-1.0** - Invalid guess (out of bounds)
+                - 💔 **-5.0** - Failed to guess in time
+                """
+            )
+
+        # API Information
+        with gr.Accordion("🔌 API Access", open=False):
+            gr.Markdown(
+                """
+                ### Use this environment in your code:
+
+                ```python
+                from envs.number_guess_env import NumberGuessEnv, GuessAction
+
+                # Connect to this deployed space
+                env = NumberGuessEnv(base_url="https://YOUR-SPACE-URL.hf.space")
+
+                # Play the game
+                result = env.reset()
+                result = env.step(GuessAction(guess=50))
+                print(result.observation.hint)
+                ```
+
+                ### API Endpoints:
+                - `POST /reset` - Start new game
+                - `POST /step` - Make a guess
+                - `GET /state` - Get current state
+                - `GET /health` - Health check
+                """
+            )
+
+        # Event handlers
+        guess_btn.click(
+            fn=make_guess,
+            inputs=[guess_input, history_table],
+            outputs=[welcome, status, attempts, reward_display, hint_display, history_table, guess_input]
+        )
+
+        # Allow Enter key to submit guess
+        guess_input.submit(
+            fn=make_guess,
+            inputs=[guess_input, history_table],
+            outputs=[welcome, status, attempts, reward_display, hint_display, history_table, guess_input]
+        )
+
+        reset_btn.click(
+            fn=reset_game,
+            inputs=[],
+            outputs=[welcome, status, attempts, reward_display, hint_display, history_table]
+        )
+
+        # Footer
+        gr.Markdown(
+            """
+            ---
+
+            Built with [OpenEnv](https://github.com/meta-pytorch/OpenEnv) |
+            Powered by [Gradio](https://gradio.app) |
+            Deployed on [Hugging Face Spaces](https://huggingface.co/spaces)
+            """
+        )
+
+    return demo
+
+
+# Create the Gradio app
+gradio_app = create_gradio_interface()
+
+if __name__ == "__main__":
+    # For local testing
+    gradio_app.launch(server_name="0.0.0.0", server_port=7860)

server/requirements.txt

@@ -3,6 +3,7 @@ fastapi>=0.104.0
 uvicorn>=0.24.0
 pydantic>=2.0.0
 requests>=2.25.0
+gradio>=4.0.0
 
 # For openenv-core if not using in-repo imports
 # openenv-core>=0.1.0

server/standalone_app.py

@@ -216,6 +216,17 @@ app = FastAPI(title="Number Guessing Game Environment")
 # Create environment instance
 env = NumberGuessEnvironment()
 
+# Import and mount Gradio interface at /web
+try:
+    from gradio_ui import gradio_app
+    import gradio as gr
+
+    # Mount Gradio app at /web path
+    app = gr.mount_gradio_app(app, gradio_app, path="/web")
+except ImportError:
+    # Gradio not available, skip web interface
+    pass
+
 
 @app.get("/")
 async def root():