Update app.py

app.py

@@ -2,129 +2,109 @@ import gradio as gr
 import pandas as pd
 import requests
 import joblib
-import xgboost # Ensure this is the version your xgb_model.joblib was trained with
+import xgboost
+
+print(f"Gradio version at script start: {gr.__version__}") # For debugging
 
 # --- Model Loading ---
 try:
     model = joblib.load('xgb_model.joblib')
     print("Model loaded successfully.")
 except FileNotFoundError:
-    print("ERROR: Model file 'xgb_model.joblib' not found. The application will not be able to make predictions.")
+    print("ERROR: Model file 'xgb_model.joblib' not found. Predictions will fail.")
     model = None
 except Exception as e:
     print(f"Error loading model: {e}")
     model = None
 
-# --- Helper Function for FDR ---
+# --- Helper Function for FDR (get_next_fdr) ---
+# (Your get_next_fdr function code remains the same here)
 def get_next_fdr(team_id, fixtures_df):
     """
     Finds the next fixture difficulty rating (FDR) for a given team.
     """
-    # Filter for upcoming fixtures for the given team
     upcoming = fixtures_df[
         ((fixtures_df["team_h"] == team_id) | (fixtures_df["team_a"] == team_id)) &
         (fixtures_df["finished"] == False)
     ]
-
     if not upcoming.empty:
-        # Drop rows where 'event' (gameweek) is NaN before sorting
         upcoming = upcoming.dropna(subset=['event'])
-        if upcoming.empty: # Check again if all upcoming fixtures had NaN events
+        if upcoming.empty:
             return None
-        
-        # Sort by event (gameweek) to find the very next one
         next_fixture = upcoming.sort_values("event").iloc[0]
-        
-        # Determine if the team is home or away for the next fixture and return corresponding FDR
         if next_fixture["team_h"] == team_id:
             return next_fixture["team_h_difficulty"]
         else:
             return next_fixture["team_a_difficulty"]
     else:
-        return None # No upcoming fixtures found
+        return None
 
-# --- Main Prediction Function ---
+# --- Main Prediction Function (predict_fpl_points) ---
+# (Your predict_fpl_points function code remains the same here)
 def predict_fpl_points(search_name=""):
     """
     Fetches FPL player data, calculates their next FDR,
     and predicts their FPL points for the next gameweek.
     """
     if model is None:
-        # This error will be displayed in the Gradio UI if model loading failed
         return pd.DataFrame({"Error": ["Model could not be loaded. Please check server logs."]})
 
     print(f"Fetching latest FPL data... Search term: '{search_name}'")
     try:
-        # Fetching general player data
         players_url = "https://fantasy.premierleague.com/api/bootstrap-static/"
         response = requests.get(players_url, timeout=20)
-        response.raise_for_status() # Raise an HTTPError for bad responses (4XX or 5XX)
+        response.raise_for_status() 
         players_data = response.json()
         
         players = pd.DataFrame(players_data["elements"])[
             ["id", "web_name", "team", "form", "element_type"]
         ]
-        # Ensure element_type is numeric for isin check, if it's not already
         players["element_type"] = pd.to_numeric(players["element_type"], errors='coerce')
-        players = players[players["element_type"].isin([1, 2, 3, 4])] # Assuming 1:GK, 2:DEF, 3:MID, 4:FWD
-        players["team"] = players["team"].astype(int) # Team IDs are integers
+        players = players[players["element_type"].isin([1, 2, 3, 4])] 
+        players["team"] = players["team"].astype(int)
 
-        # Fetching fixtures data
         fixtures_url = "https://fantasy.premierleague.com/api/fixtures/"
         fixtures_response = requests.get(fixtures_url, timeout=20)
         fixtures_response.raise_for_status()
         fixtures_data = fixtures_response.json()
         fixtures = pd.DataFrame(fixtures_data)
 
-        # Ensure relevant fixture columns are numeric, coercing errors to NaN
         cols_to_numeric = ["team_h", "team_a", "team_h_difficulty", "team_a_difficulty", "event"]
         for col in cols_to_numeric:
             if col in fixtures.columns:
                 fixtures[col] = pd.to_numeric(fixtures[col], errors='coerce')
-            else:
-                # Handle missing essential columns if necessary, though FPL API is usually consistent
-                print(f"Warning: Fixture column '{col}' not found in API response.")
-                # Depending on severity, you might return an error DataFrame here
         
         print("FPL data fetched successfully.")
 
     except requests.exceptions.RequestException as e:
         print(f"Error fetching data from FPL API: {e}")
         return pd.DataFrame({"Error": [f"Failed to fetch FPL data: {e}. Please try again later."]})
-    except Exception as e: # Catch other potential errors during data fetching (e.g., JSON parsing)
+    except Exception as e:
          print(f"An unexpected error occurred during data fetching: {e}")
          return pd.DataFrame({"Error": [f"An unexpected error occurred during data fetching: {e}"]})
 
     print("Calculating next FDR and preparing data for prediction...")
     try:
         players_with_fdr = players.copy()
-        # Apply the get_next_fdr function to each player
         players_with_fdr["next_fdr"] = players_with_fdr["team"].apply(
             lambda team_id: get_next_fdr(team_id, fixtures)
         )
 
-        # Clean data: drop players with missing FDR or form, ensure types are correct
         players_clean = players_with_fdr.dropna(subset=["next_fdr", "form"])
         players_clean["form"] = pd.to_numeric(players_clean["form"], errors='coerce')
         players_clean["next_fdr"] = pd.to_numeric(players_clean["next_fdr"], errors='coerce')
-        # Drop rows where form or next_fdr could not be converted to numeric
         players_clean = players_clean.dropna(subset=["form", "next_fdr"])
 
         if players_clean.empty:
              print("No players found after cleaning (missing form or next FDR).")
-             # Return a DataFrame with a message, ensuring columns match output expectations for consistency
-             return pd.DataFrame({"Message": ["No eligible players found after data cleaning (missing form or next FDR)."]})
+             return pd.DataFrame({"Message": ["No eligible players found after data cleaning."]})
 
         print(f"Predicting points for {len(players_clean)} players...")
-        # Define features used by the model
         features = ["form", "next_fdr"]
         X_next = players_clean[features]
-
-        # Make predictions
         players_clean.loc[:, "predicted_points"] = model.predict(X_next)
         print("Prediction complete.")
 
-        # Prepare output DataFrame
         output_df_base = players_clean[["web_name", "predicted_points", "form", "next_fdr"]].copy()
         output_df_base.rename(columns={
             "web_name": "Player",
@@ -132,79 +112,154 @@ def predict_fpl_points(search_name=""):
             "form": "Form",
             "next_fdr": "Next FDR (Lower is easier)"
         }, inplace=True)
-        # Round predicted points for better readability
         output_df_base.loc[:, "Predicted Points"] = output_df_base["Predicted Points"].round(2)
 
-        # Handle search functionality
         if search_name and search_name.strip():
             print(f"Filtering for player name containing: '{search_name}'")
-            # Case-insensitive search
             search_results = output_df_base[
                 output_df_base['Player'].str.contains(search_name.strip(), case=False, na=False)
             ]
-
             if not search_results.empty:
-                search_results = search_results.sort_values("Predicted Points", ascending=False)
-                return search_results
+                return search_results.sort_values("Predicted Points", ascending=False)
             else:
-                # No player found matching search term
-                return pd.DataFrame({"Message": [f"No player found matching '{search_name}'. Try a different name or leave blank for top players."]})
+                return pd.DataFrame({"Message": [f"No player found matching '{search_name}'."]})
         else:
-            # No search term, return top N players
             print("No search term provided, returning top 20 predicted players.")
-            top_players = output_df_base.sort_values("Predicted Points", ascending=False).head(20)
-            return top_players
+            return output_df_base.sort_values("Predicted Points", ascending=False).head(20)
 
     except KeyError as e:
-        print(f"KeyError during data processing: {e}. This might indicate an unexpected API data structure or a typo in column names.")
+        print(f"KeyError during data processing: {e}.")
         import traceback
         traceback.print_exc()
-        return pd.DataFrame({"Error": [f"Data processing error (Missing Key): {e}. Check FPL API structure."]})
+        return pd.DataFrame({"Error": [f"Data processing error (Missing Key): {e}."]})
     except Exception as e:
         print(f"An error occurred during prediction/processing: {e}")
         import traceback
         traceback.print_exc()
         return pd.DataFrame({"Error": [f"Prediction or data processing failed: {e}"]})
 
-# --- Gradio Interface Definition ---
-iface = gr.Interface(
-    fn=predict_fpl_points,
-    inputs=gr.Textbox(
-        label="Search for Player (Optional)",
-        placeholder="E.g., Salah, Haaland, Saka... Leave blank for Top 20",
-        mcp_label="player_search_input"  # MCP label for this input component
-    ),
-    outputs=gr.DataFrame(
+
+# --- Gradio UI Definition using gr.Blocks ---
+with gr.Blocks(theme=gr.themes.Soft(), title="Fantasy Premier League Player Point Predictor") as demo:
+    gr.Markdown(
+        """
+        # Fantasy Premier League Player Point Predictor
+        Predicts FPL points for the *next* gameweek based on current form and upcoming fixture difficulty (FDR). 
+        Enter a player name to search, or leave blank to see the top 20 predicted players. Fetches live data.
+        """
+    ) # You can add "(MCP Enabled)" to the title/markdown if MCP features load successfully
+
+    with gr.Row():
+        player_search_input = gr.Textbox(
+            label="Search for Player (Optional)",
+            placeholder="E.g., Salah, Haaland, Saka... Leave blank for Top 20",
+            # Add mcp_label if MCP features are correctly installed and working
+            # mcp_label="player_search_input_blocks" 
+        )
+
+    predict_button = gr.Button("Predict Points")
+
+    prediction_output_dataframe = gr.DataFrame(
         label="Predicted Player Data (Next Gameweek)",
         wrap=True,
-        mcp_label="prediction_output_dataframe"  # MCP label for this output component
-    ),
-    title="Fantasy Premier League Player Point Predictor (MCP Enabled)",
-    description="Predicts FPL points for the *next* gameweek based on current form and upcoming fixture difficulty (FDR). "
-                "Enter a player name to search, or leave blank to see the top 20 predicted players. Fetches live data. "
-                "MCP server enabled for model card data collection.",
-    allow_flagging='never', # Flagging not used for MCP data collection here
-    theme=gr.themes.Soft(),
-    examples=[[""], ["Son"], ["Watkins"], ["Palmer"]] # Examples for user convenience
-)
+        # Add mcp_label if MCP features are correctly installed and working
+        # mcp_label="prediction_output_dataframe_blocks"
+    )
+
+    gr.Examples(
+        examples=[[""], ["Son"], ["Watkins"], ["Palmer"]],
+        inputs=player_search_input,
+        # You could also have outputs and fn here if examples should pre-run,
+        # but for dynamic input, just setting input is common.
+    )
+
+    # Define the action for the button click
+    predict_button.click(
+        fn=predict_fpl_points,
+        inputs=player_search_input,
+        outputs=prediction_output_dataframe
+    )
 
 # --- Application Launch ---
 if __name__ == "__main__":
-    print("Attempting to launch Gradio app with MCP server...")
-    # CRITICAL: For mcp_server=True to work, 'gradio[mcp]' must be correctly
-    # installed in your Hugging Face Space environment via requirements.txt.
-    # If you still get 'unexpected keyword argument mcp_server',
-    # it means the MCP extensions for Gradio are not active.
-    # Double-check requirements.txt and ensure your Space has rebuilt.
+    print(f"Gradio version before launch: {gr.__version__}")
+    
+    # Attempt to add MCP labels dynamically if the Gradio version seems to support it
+    # This is a bit of a workaround due to the persistent environment issues.
+    # Ideally, you'd just define them directly if the env was correct.
+    mcp_is_likely_available = False
+    try:
+        # A simple test: does Textbox accept mcp_label?
+        # This is a rough check and might not be perfectly reliable for all Gradio versions/setups.
+        # The real check is whether 'gradio[mcp]' was correctly installed.
+        _ = gr.Textbox(mcp_label="test") 
+        mcp_is_likely_available = True
+        print("MCP features (like mcp_label) seem available in this Gradio version.")
+    except TypeError:
+        print("WARNING: MCP features (like mcp_label) are NOT available in this Gradio version. MCP server might fail or not collect specific data.")
+        print(f"This is likely due to an issue with 'gradio[mcp]' installation or an incompatible Gradio version ({gr.__version__}) in the environment.")
+
+    if mcp_is_likely_available:
+        # If MCP seems available, re-define components within Blocks with mcp_label
+        # This is done by re-creating the demo object if we want to add them now.
+        # For simplicity in this example, I'll just note that you would have defined them above directly.
+        # The `mcp_label`s in the Blocks definition above are commented out;
+        # you'd uncomment them if your environment was fixed.
+        # For now, we'll proceed, and launch will attempt mcp_server=True
+        print("Proceeding with mcp_server=True. If it fails, it confirms environment issues.")
+        if hasattr(player_search_input, 'mcp_label'): # This check is illustrative
+            player_search_input.mcp_label = "player_search_input_blocks"
+            prediction_output_dataframe.mcp_label = "prediction_output_dataframe_blocks"
+            demo.title = "Fantasy Premier League Player Point Predictor (MCP Enabled)"
+            demo.blocks[0].value = demo.blocks[0].value.replace("Player Point Predictor", "Player Point Predictor (MCP Enabled)")
+
+
+    print("Attempting to launch Gradio app...")
     try:
-        iface.launch(mcp_server=True)
+        # Try to launch with mcp_server=True
+        demo.launch(mcp_server=True)
     except TypeError as e:
-        if 'mcp_server' in str(e):
-            print("\nERROR: Failed to launch with mcp_server=True. ")
-            print("This usually means the 'gradio[mcp]' extras are not installed correctly.")
-            print("Please ensure 'gradio[mcp]' is in your requirements.txt and your Hugging Face Space has been rebuilt.\n")
-            # Fallback: Launch without mcp_server if it fails, so the app still runs
-            print("Attempting to launch without MCP server as a fallback...")
-            iface.launch()
+        if 'mcp_server' in str(e) or 'mcp_label' in str(e):
+            print("\nERROR: Failed to launch with MCP features (mcp_server or mcp_label not recognized).")
+            print(f"Gradio version being used: {gr.__version__}")
+            print("This confirms that 'gradio[mcp]' extras are not correctly installed or it's an incompatible Gradio version.")
+            print("If you are on Hugging Face Spaces, ensure your environment (requirements.txt, Dockerfile if used, or SDK settings) correctly installs a recent 'gradio[mcp]'.\n")
+            print(f"Error details: {e}")
+            
+            print("Attempting to launch Gradio app WITHOUT MCP server as a fallback...")
+            # Fallback launch:
+            # Create a new Blocks instance without attempting MCP features if the first one is problematic
+            with gr.Blocks(theme=gr.themes.Soft(), title="Fantasy Premier League Player Point Predictor (MCP Fallback)") as fallback_demo:
+                gr.Markdown(
+                    """
+                    # Fantasy Premier League Player Point Predictor (MCP Features Failed to Load)
+                    Predicts FPL points for the *next* gameweek based on current form and upcoming fixture difficulty (FDR). 
+                    Enter a player name to search, or leave blank to see the top 20 predicted players. Fetches live data.
+                    """
+                )
+                with gr.Row():
+                    player_search_input_fb = gr.Textbox( # no mcp_label
+                        label="Search for Player (Optional)",
+                        placeholder="E.g., Salah, Haaland, Saka... Leave blank for Top 20"
+                    )
+                predict_button_fb = gr.Button("Predict Points")
+                prediction_output_dataframe_fb = gr.DataFrame( # no mcp_label
+                    label="Predicted Player Data (Next Gameweek)",
+                    wrap=True
+                )
+                gr.Examples(
+                    examples=[[""], ["Son"], ["Watkins"], ["Palmer"]],
+                    inputs=player_search_input_fb,
+                )
+                predict_button_fb.click(
+                    fn=predict_fpl_points,
+                    inputs=player_search_input_fb,
+                    outputs=prediction_output_dataframe_fb
+                )
+            fallback_demo.launch()
         else:
-            raise e # Re-raise other TypeErrors
+            # Re-raise other TypeErrors not related to MCP
+            raise e
+    except Exception as general_e:
+        print(f"A general error occurred during launch: {general_e}")
+        # Potentially try the fallback launch here too if it's a critical launch failure