app.py

import gradio as gr
import pandas as pd
import requests
import joblib
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. Predictions will fail.")
    model = None
except Exception as e:
    print(f"Error loading model: {e}")
    model = None

# --- 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.
    """
    upcoming = fixtures_df[
        ((fixtures_df["team_h"] == team_id) | (fixtures_df["team_a"] == team_id)) &
        (fixtures_df["finished"] == False)
    ]
    if not upcoming.empty:
        upcoming = upcoming.dropna(subset=['event'])
        if upcoming.empty:
            return None
        next_fixture = upcoming.sort_values("event").iloc[0]
        if next_fixture["team_h"] == team_id:
            return next_fixture["team_h_difficulty"]
        else:
            return next_fixture["team_a_difficulty"]
    else:
        return None

# --- 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:
        return pd.DataFrame({"Error": ["Model could not be loaded. Please check server logs."]})

    print(f"Fetching latest FPL data... Search term: '{search_name}'")
    try:
        players_url = "https://fantasy.premierleague.com/api/bootstrap-static/"
        response = requests.get(players_url, timeout=20)
        response.raise_for_status() 
        players_data = response.json()
        
        players = pd.DataFrame(players_data["elements"])[
            ["id", "web_name", "team", "form", "element_type"]
        ]
        players["element_type"] = pd.to_numeric(players["element_type"], errors='coerce')
        players = players[players["element_type"].isin([1, 2, 3, 4])] 
        players["team"] = players["team"].astype(int)

        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)

        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')
        
        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:
         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()
        players_with_fdr["next_fdr"] = players_with_fdr["team"].apply(
            lambda team_id: get_next_fdr(team_id, fixtures)
        )

        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')
        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 pd.DataFrame({"Message": ["No eligible players found after data cleaning."]})

        print(f"Predicting points for {len(players_clean)} players...")
        features = ["form", "next_fdr"]
        X_next = players_clean[features]
        players_clean.loc[:, "predicted_points"] = model.predict(X_next)
        print("Prediction complete.")

        output_df_base = players_clean[["web_name", "predicted_points", "form", "next_fdr"]].copy()
        output_df_base.rename(columns={
            "web_name": "Player",
            "predicted_points": "Predicted Points",
            "form": "Form",
            "next_fdr": "Next FDR (Lower is easier)"
        }, inplace=True)
        output_df_base.loc[:, "Predicted Points"] = output_df_base["Predicted Points"].round(2)

        if search_name and search_name.strip():
            print(f"Filtering for player name containing: '{search_name}'")
            search_results = output_df_base[
                output_df_base['Player'].str.contains(search_name.strip(), case=False, na=False)
            ]
            if not search_results.empty:
                return search_results.sort_values("Predicted Points", ascending=False)
            else:
                return pd.DataFrame({"Message": [f"No player found matching '{search_name}'."]})
        else:
            print("No search term provided, returning top 20 predicted players.")
            return output_df_base.sort_values("Predicted Points", ascending=False).head(20)

    except KeyError as e:
        print(f"KeyError during data processing: {e}.")
        import traceback
        traceback.print_exc()
        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 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,
        # 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(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:
        # Try to launch with mcp_server=True
        demo.launch(mcp_server=True)
    except TypeError as e:
        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:
            # 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