Update app.py

app.py

@@ -3,25 +3,20 @@ import uuid
 import httpx
 import os
 
+# Import spaces early
+import spaces
+print("[APP] Spaces imported successfully")
+
+# Import the LLM service and GPU function EARLY to ensure detection
+from RockPaperScissor.services.LLM_service import LLMService, generate_text_with_gpu, llm_service_instance
+print(f"[APP] LLM GPU function imported: {generate_text_with_gpu.__name__}")
+
 # FastAPI imports
 from fastapi import FastAPI, Request, Body
 from fastapi.responses import RedirectResponse
 from RockPaperScissor.routes import game_router
 from RockPaperScissor.services.service_instance import game_service
 
-# Import the LLM service and GPU function
-from RockPaperScissor.services.LLM_service import LLMService, generate_text_with_gpu, llm_service_instance
-
-# Import spaces after the GPU function is defined
-try:
-    import spaces
-    from spaces import GPU
-    print("[APP] spaces.GPU imported successfully")
-except ImportError:
-    print("[APP] spaces.GPU not available")
-    def GPU(f):
-        return f
-
 # --- Game Constants and Types ---
 from enum import Enum
 
@@ -46,6 +41,7 @@ class RockPaperScissorsUI:
             "adaptive_markov": "Adaptive Markov AI: Uses entropy-weighted Markov and frequency models to predict your next move."
         }
         self.last_move = None
+        print("[APP] RockPaperScissorsUI initialized")
 
     async def reset_session(self, session_id: str):
         # Use environment variable for base URL, fallback to localhost
@@ -60,6 +56,76 @@ class RockPaperScissorsUI:
         await self.game_service.clear_session(session_id)
         return {"status": "ok"}
 
+    def update_ai_description(self, ai_type):
+        """Update AI description based on selection"""
+        return self.ai_descriptions.get(ai_type, "Unknown AI type")
+
+    async def play_round(self, ai_type: str, player_move: str):
+        """Play a round of Rock Paper Scissors"""
+        try:
+            # Ensure we have a session
+            if not self.session_id:
+                self.session_id = f"session_{uuid.uuid4()}"
+            
+            # Make the move via the game service
+            result = await self.game_service.play_round(
+                self.session_id, 
+                player_move, 
+                ai_type
+            )
+            
+            # Format the result for display
+            player_emoji = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
+            ai_emoji = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
+            
+            result_text = f"""
+## Last Round
+**You:** {player_emoji[player_move]} {player_move.title()}  
+**AI:** {ai_emoji[result['ai_move']]} {result['ai_move'].title()}  
+**Result:** {result['result'].replace('_', ' ').title()}
+
+## Game Statistics
+**Rounds Played:** {result['stats']['total_rounds']}  
+**Your Wins:** {result['stats']['player_wins']}  
+**AI Wins:** {result['stats']['ai_wins']}  
+**Draws:** {result['stats']['draws']}  
+**Win Rate:** {result['stats']['player_win_rate']:.1f}%
+"""
+            
+            stats_text = f"""
+### AI Move Distribution
+**Rock:** {result['stats']['move_distribution']['rock']} times  
+**Paper:** {result['stats']['move_distribution']['paper']} times  
+**Scissors:** {result['stats']['move_distribution']['scissors']} times
+"""
+            
+            self.last_move = player_move
+            return stats_text, result_text
+            
+        except Exception as e:
+            print(f"[APP] Error in play_round: {e}")
+            return f"Error: {str(e)}", "Please try again"
+
+    async def get_ai_help(self, session_id: str):
+        """Get strategic advice from the AI"""
+        try:
+            if not session_id:
+                return "Play a few rounds first to get personalized advice!"
+            
+            # Get current game stats
+            stats = await self.game_service.get_session_stats(session_id)
+            
+            if not stats or stats.get('total_rounds', 0) == 0:
+                return "Play a few rounds first to get personalized advice!"
+            
+            # Use the LLM service for strategic advice
+            advice = await llm_service_instance.generate_response("", stats)
+            return advice
+            
+        except Exception as e:
+            print(f"[APP] Error getting AI help: {e}")
+            return ">>> Try to observe patterns in the AI's moves and counter them strategically!\nRecommendation: Rock"
+
     def create_interface(self):
         with gr.Blocks(theme=gr.themes.Soft(), title="Rock Paper Scissors 🎮") as demo:
             gr.Markdown("# 🪨📄✂️ Rock Paper Scissors")
@@ -78,19 +144,19 @@ class RockPaperScissorsUI:
                         rock_btn = gr.Button("🪨 Rock", variant="secondary", elem_classes=["move-btn"])
                         paper_btn = gr.Button("📄 Paper", variant="secondary", elem_classes=["move-btn"])
                         scissors_btn = gr.Button("✂️ Scissors", variant="secondary", elem_classes=["move-btn"])
+                    
                     # Add End Game button
                     end_btn = gr.Button("End Game", variant="stop", elem_id="end-game-btn")
                     # Add Help button
-                    help_btn = gr.Button("💡 Get Help", variant="primary", elem_id="help-btn")
+                    help_btn = gr.Button("💡 Get AI Help", variant="primary", elem_id="help-btn")
                     # Add a dedicated box for the help answer, initially empty
-                    help_answer_box = gr.Markdown("", visible=True)
+                    help_answer_box = gr.Markdown("Click 'Get AI Help' for strategic advice!", visible=True)
 
                 with gr.Column(scale=2):
                     gr.Markdown("### 📊 Game Statistics")
-                    stats_display = gr.Markdown()
+                    stats_display = gr.Markdown("Play a round to see statistics!")
                     result_display = gr.Markdown("Make your move!")
                     end_result_display = gr.Markdown(visible=False)
-                    status_display = gr.Markdown(visible=True)
 
             ai_dropdown.change(
                 fn=self.update_ai_description,
@@ -99,7 +165,6 @@ class RockPaperScissorsUI:
             )
 
             # Use a Gradio State to store the session ID
-            move_state = gr.State("")
             session_id_state = gr.State("")
 
             async def play_rock(ai_type, session_id):
@@ -108,12 +173,14 @@ class RockPaperScissorsUI:
                 self.session_id = session_id
                 stats, result = await self.play_round(ai_type, "rock")
                 return stats, result, session_id
+
             async def play_paper(ai_type, session_id):
                 if not session_id:
                     session_id = f"session_{uuid.uuid4()}"
                 self.session_id = session_id
                 stats, result = await self.play_round(ai_type, "paper")
                 return stats, result, session_id
+
             async def play_scissors(ai_type, session_id):
                 if not session_id:
                     session_id = f"session_{uuid.uuid4()}"
@@ -121,195 +188,71 @@ class RockPaperScissorsUI:
                 stats, result = await self.play_round(ai_type, "scissors")
                 return stats, result, session_id
 
-            # Add a hidden HTML block with JS to auto-save on tab close
-            gr.HTML("""
-    <script>
-    // Store session ID in localStorage whenever it changes
-    window.setRpsSessionId = function(session_id) {
-        if (session_id) {
-            localStorage.setItem('rps_session_id', session_id);
-        }
-    };
-    // On tab close, send session end to backend
-    window.onbeforeunload = function() {
-        let session_id = localStorage.getItem('rps_session_id');
-        if (session_id) {
-            navigator.sendBeacon("/game/end", JSON.stringify({session_id: session_id}));
-        }
-    };
-    </script>
-    """)
-
-            # Inject JS to click End Game button on tab close
-            gr.HTML("""
-<script>
-window.onbeforeunload = function() {
-    var btn = document.getElementById('end-game-btn');
-    if (btn) {
-        btn.click();
-    }
-};
-</script>
-""")
-
-            # After each move, update localStorage with the session ID
-            def update_session_id_js(session_id):
-                return f"window.setRpsSessionId('{session_id}');"
-
+            # Button click handlers
             rock_btn.click(
                 fn=play_rock,
                 inputs=[ai_dropdown, session_id_state],
-                outputs=[stats_display, result_display, session_id_state],
-                js=update_session_id_js
+                outputs=[stats_display, result_display, session_id_state]
             )
             paper_btn.click(
                 fn=play_paper,
                 inputs=[ai_dropdown, session_id_state],
-                outputs=[stats_display, result_display, session_id_state],
-                js=update_session_id_js
+                outputs=[stats_display, result_display, session_id_state]
             )
             scissors_btn.click(
                 fn=play_scissors,
                 inputs=[ai_dropdown, session_id_state],
-                outputs=[stats_display, result_display, session_id_state],
-                js=update_session_id_js
+                outputs=[stats_display, result_display, session_id_state]
             )
 
             # End Game button logic
             async def end_game(session_id):
                 if not session_id:
                     return "No session to end. Play a round first!"
-                result = await self.reset_session(session_id)
-                return f"End Game: {result['status']} - {result.get('message', '')}"
+                try:
+                    result = await self.reset_session(session_id)
+                    return f"Game ended successfully! Start a new game by making a move."
+                except Exception as e:
+                    return f"Error ending game: {str(e)}"
 
             end_btn.click(
                 fn=end_game,
                 inputs=[session_id_state],
-                outputs=[end_result_display],
+                outputs=[end_result_display]
             )
-            end_result_display.visible = True
-
+            
             # Help button logic
-            async def get_help(session_id):
-                # Show loading message while waiting
-                loading_message = "Generating answer, please wait..."
-                try:
-                    base_url = os.getenv("HF_SPACE_URL", "http://localhost:7860")
-                    async with httpx.AsyncClient() as client:
-                        response = await client.post(f"{base_url}/api/help", json={"session_id": session_id})
-                        if response.status_code == 200:
-                            data = response.json()
-                            suggestion = data.get("suggestion", "No suggestion available.")
-                        else:
-                            suggestion = "Sorry, I'm having trouble getting help right now."
-                except Exception as e:
-                    suggestion = f"Error getting help: {str(e)}"
-                return suggestion
-
-            # When help button is clicked, first show loading, then update with answer
-            def show_loading():
-                return "Generating answer, please wait..."
-
-            help_btn.click(
-                fn=show_loading,
-                inputs=[],
-                outputs=[help_answer_box],
-                queue=False
-            )
             help_btn.click(
-                fn=get_help,
+                fn=self.get_ai_help,
                 inputs=[session_id_state],
-                outputs=[help_answer_box],
-                queue=True
+                outputs=[help_answer_box]
             )
 
-        return demo
-
-    def update_ai_description(self, ai_type: str) -> str:
-        return self.ai_descriptions[ai_type]
-
-    async def play_round(self, ai_type: str, move: str):
-        if not self.session_id: 
-            return "Internal Error: Session ID missing in play_round.", "Error"
-        result = await self.game_service.play_round(self.session_id, move, ai_type)
-        stats = result["stats"]
-        stats_text = f"""
-        ### Game Statistics
-        - Total Rounds: {stats['total_rounds']}
-        - Player Wins: {stats['player_wins']} ({stats['player_win_rate']})
-        - AI Wins: {stats['ai_wins']} ({stats['ai_win_rate']})
-        - Draws: {stats['draws']}
-
-        ### Player Move Distribution
-        - Rock: {stats['player_moves']['rock']}
-        - Paper: {stats['player_moves']['paper']}
-        - Scissors: {stats['player_moves']['scissors']}
-
-        ### AI Move Distribution
-        - Rock: {stats['ai_moves']['rock']}
-        - Paper: {stats['ai_moves']['paper']}
-        - Scissors: {stats['ai_moves']['scissors']}
-        """
-        result_text = f"""
-        ### Round Result
-        You played: {result['player_move'].upper()}
-        AI played: {result['ai_move'].upper()}
-        Result: {result['result'].replace('_', ' ').title()}
-        """
-        return stats_text, result_text
+            end_result_display.visible = True
 
-    async def clear_session(self, session_id: str):
-        await self.game_service.clear_session(session_id)
-        return {"status": "ok"}
+        return demo
 
-# Create FastAPI app
+# Create the FastAPI app
 app = FastAPI()
 
-# Add help endpoint
-@app.post("/api/help")
-async def get_help(request: Request, body: dict = Body(...)):
-    try:
-        session_id = body.get("session_id")
-        stats = None
-        if session_id:
-            # Try to get stats from the game service
-            session_data = game_service.cache.get_session(session_id)
-            if session_data:
-                # Calculate AI move distribution
-                ai_moves = [round['ai_move'] for round in session_data['rounds']]
-                total_moves = len(ai_moves)
-                if total_moves > 0:
-                    move_distribution = {
-                        "rock": int((ai_moves.count("rock") / total_moves) * 100),
-                        "paper": int((ai_moves.count("paper") / total_moves) * 100),
-                        "scissors": int((ai_moves.count("scissors") / total_moves) * 100)
-                    }
-                    stats = {"move_distribution": move_distribution}
-        suggestion = await llm_service_instance.generate_response("help", stats=stats)
-        print("Help suggestion:", suggestion)  # Debug print
-        return {"suggestion": suggestion}
-    except Exception as e:
-        return {"error": str(e), "suggestion": "Sorry, I'm having trouble generating a suggestion right now."}
+# Add the game routes
+app.include_router(game_router, prefix="/api")
+
+@app.get("/")
+async def root():
+    return RedirectResponse(url="/gradio")
 
-# Create Gradio interface
+# Create the UI
 ui = RockPaperScissorsUI(game_service)
 demo = ui.create_interface()
 
-# Mount Gradio app
-app.include_router(game_router, prefix="/api/game")
-app = gr.mount_gradio_app(app, demo, path="/")
-
-# Initialize the app
-@app.on_event("startup")
-async def startup_event():
-    await game_service.initialize()
-    print("[APP] Startup complete - LLM will initialize on first use")
-    print(f"[APP] GPU function available: {generate_text_with_gpu}")
+# Mount Gradio on FastAPI
+app = gr.mount_gradio_app(app, demo, path="/gradio")
 
-@app.on_event("shutdown")
-async def shutdown_event():
-    await llm_service_instance.close()
+print("[APP] Application setup completed successfully")
+print(f"[APP] GPU function status: {generate_text_with_gpu.__name__} ready")
 
 if __name__ == "__main__":
+    print("[APP] Starting application...")
     import uvicorn
-    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)
+    uvicorn.run(app, host="0.0.0.0", port=7860)