fpl-mcp-server 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

src/tools/teams.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from ..client import FPLClient
 from ..constants import CHARACTER_LIMIT
-from ..formatting import format_difficulty_indicator, format_team_details
+from ..formatting import format_difficulty_indicator
 from ..state import store
 from ..utils import (
     ResponseFormat,
@@ -15,34 +15,6 @@ from ..utils import (
 from . import mcp
 
 
-class GetTeamInfoInput(BaseModel):
-    """Input model for getting team information."""
-
-    model_config = ConfigDict(str_strip_whitespace=True, validate_assignment=True)
-
-    team_name: str = Field(
-        ...,
-        description="Team name or abbreviation (e.g., 'Arsenal', 'MCI', 'Liverpool')",
-        min_length=2,
-        max_length=50,
-    )
-    response_format: ResponseFormat = Field(
-        default=ResponseFormat.MARKDOWN,
-        description="Output format: 'markdown' for human-readable or 'json' for machine-readable",
-    )
-
-
-class ListAllTeamsInput(BaseModel):
-    """Input model for listing all teams."""
-
-    model_config = ConfigDict(str_strip_whitespace=True, validate_assignment=True)
-
-    response_format: ResponseFormat = Field(
-        default=ResponseFormat.MARKDOWN,
-        description="Output format: 'markdown' for human-readable or 'json' for machine-readable",
-    )
-
-
 class AnalyzeTeamFixturesInput(BaseModel):
     """Input model for analyzing team fixtures."""
 
@@ -71,150 +43,6 @@ async def _create_client():
     return client
 
 
-@mcp.tool(
-    name="fpl_get_team_info",
-    annotations={
-        "title": "Get FPL Team Information",
-        "readOnlyHint": True,
-        "destructiveHint": False,
-        "idempotentHint": True,
-        "openWorldHint": True,
-    },
-)
-async def fpl_get_team_info(params: GetTeamInfoInput) -> str:
-    """
-    Get detailed information about a specific Premier League team.
-
-    Returns team strength ratings for home/away attack/defence, useful for assessing
-    which teams have strong defensive or attacking potential.
-
-    Args:
-        params (GetTeamInfoInput): Validated input parameters containing:
-            - team_name (str): Team name or abbreviation (e.g., 'Arsenal', 'MCI')
-            - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)
-
-    Returns:
-        str: Detailed team information with strength ratings
-
-    Examples:
-        - Get Arsenal info: team_name="Arsenal"
-        - Use abbreviation: team_name="LIV"
-        - Get JSON format: team_name="Man City", response_format="json"
-
-    Error Handling:
-        - Returns error if no team found
-        - Returns error if multiple teams match (asks user to be more specific)
-        - Returns formatted error message if data unavailable
-    """
-    try:
-        await _create_client()
-        if not store.bootstrap_data:
-            return "Error: Team data not available. Please try again later."
-
-        matching_teams = [
-            t
-            for t in store.bootstrap_data.teams
-            if params.team_name.lower() in t.name.lower()
-            or params.team_name.lower() in t.short_name.lower()
-        ]
-
-        if not matching_teams:
-            return f"No team found matching '{params.team_name}'. Try using the full team name or abbreviation."
-
-        if len(matching_teams) > 1:
-            team_list = ", ".join([f"{t.name} ({t.short_name})" for t in matching_teams])
-            return f"Multiple teams found: {team_list}. Please be more specific."
-
-        team = matching_teams[0]
-        team_dict = store.get_team_by_id(team.id)
-
-        if params.response_format == ResponseFormat.JSON:
-            return format_json_response(team_dict)
-        else:
-            # Convert Team object to dict for formatter
-            team_dict = {
-                "name": team.name,
-                "short_name": team.short_name,
-                "strength": getattr(team, "strength", None),
-                "strength_overall_home": getattr(team, "strength_overall_home", None),
-                "strength_overall_away": getattr(team, "strength_overall_away", None),
-                "strength_attack_home": getattr(team, "strength_attack_home", None),
-                "strength_attack_away": getattr(team, "strength_attack_away", None),
-                "strength_defence_home": getattr(team, "strength_defence_home", None),
-                "strength_defence_away": getattr(team, "strength_defence_away", None),
-            }
-
-            result = format_team_details(team_dict)
-            truncated, _ = check_and_truncate(result, CHARACTER_LIMIT)
-            return truncated
-
-    except Exception as e:
-        return handle_api_error(e)
-
-
-@mcp.tool(
-    name="fpl_list_all_teams",
-    annotations={
-        "title": "List All FPL Teams",
-        "readOnlyHint": True,
-        "destructiveHint": False,
-        "idempotentHint": True,
-        "openWorldHint": True,
-    },
-)
-async def fpl_list_all_teams(params: ListAllTeamsInput) -> str:
-    """
-    List all Premier League teams with their basic information.
-
-    Returns all 20 Premier League teams with their names, abbreviations, and average
-    strength ratings. Useful for finding exact team names or comparing team strengths.
-
-    Args:
-        params (ListAllTeamsInput): Validated input parameters containing:
-            - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)
-
-    Returns:
-        str: List of all teams with strength ratings
-
-    Examples:
-        - List all teams: response_format="markdown"
-        - Get as JSON: response_format="json"
-
-    Error Handling:
-        - Returns error if team data unavailable
-        - Returns formatted error message if API fails
-    """
-    try:
-        await _create_client()
-        teams = store.get_all_teams()
-        if not teams:
-            return "Error: Team data not available. Please try again later."
-
-        teams_sorted = sorted(teams, key=lambda t: t["name"])
-
-        if params.response_format == ResponseFormat.JSON:
-            return format_json_response({"count": len(teams_sorted), "teams": teams_sorted})
-        else:
-            output = ["**Premier League Teams:**\n"]
-
-            for team in teams_sorted:
-                strength_info = ""
-                if team.get("strength_overall_home") and team.get("strength_overall_away"):
-                    avg_strength = (
-                        team["strength_overall_home"] + team["strength_overall_away"]
-                    ) / 2
-                    strength_info = f" | Strength: {avg_strength:.0f}"
-
-                output.append(f"{team['name']:20s} ({team['short_name']}){strength_info}")
-
-            result = "\n".join(output)
-            truncated, _ = check_and_truncate(result, CHARACTER_LIMIT)
-            return truncated
-
-    except Exception as e:
-        return handle_api_error(e)
-
-
 @mcp.tool(
     name="fpl_analyze_team_fixtures",
     annotations={

src/tools/transfers.py

@@ -4,31 +4,17 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from ..client import FPLClient
 from ..constants import CHARACTER_LIMIT
+from ..formatting import format_player_price
 from ..state import store
 from ..utils import (
     ResponseFormat,
     check_and_truncate,
     format_json_response,
-    format_player_price,
     handle_api_error,
 )
 from . import mcp
 
 
-class GetPlayerTransfersByGameweekInput(BaseModel):
-    """Input model for getting player transfer statistics."""
-
-    model_config = ConfigDict(str_strip_whitespace=True, validate_assignment=True)
-
-    player_name: str = Field(
-        ...,
-        description="Player name (e.g., 'Haaland', 'Salah')",
-        min_length=2,
-        max_length=100,
-    )
-    gameweek: int = Field(..., description="Gameweek number (1-38)", ge=1, le=38)
-
-
 class GetTopTransferredPlayersInput(BaseModel):
     """Input model for getting top transferred players."""
 
@@ -50,6 +36,32 @@ class GetManagerTransfersByGameweekInput(BaseModel):
     gameweek: int = Field(..., description="Gameweek number (1-38)", ge=1, le=38)
 
 
+class AnalyzeTransferInput(BaseModel):
+    """Input model for analyzing a potential transfer."""
+
+    model_config = ConfigDict(str_strip_whitespace=True, validate_assignment=True)
+
+    player_out: str = Field(
+        ...,
+        description="Name of player to transfer out (e.g., 'Salah')",
+        min_length=2,
+        max_length=100,
+    )
+    player_in: str = Field(
+        ...,
+        description="Name of player to transfer in (e.g., 'Palmer')",
+        min_length=2,
+        max_length=100,
+    )
+    my_team_id: int | None = Field(
+        default=None, description="Your team ID to check budget/value impact (optional)"
+    )
+    response_format: ResponseFormat = Field(
+        default=ResponseFormat.MARKDOWN,
+        description="Output format: 'markdown' or 'json'",
+    )
+
+
 async def _create_client():
     """Create an unauthenticated FPL client for public API access and ensure data is loaded."""
     client = FPLClient(store=store)
@@ -58,103 +70,6 @@ async def _create_client():
     return client
 
 
-@mcp.tool(
-    name="fpl_get_player_transfers_by_gameweek",
-    annotations={
-        "title": "Get FPL Player Transfer Statistics",
-        "readOnlyHint": True,
-        "destructiveHint": False,
-        "idempotentHint": True,
-        "openWorldHint": True,
-    },
-)
-async def fpl_get_player_transfers_by_gameweek(
-    params: GetPlayerTransfersByGameweekInput,
-) -> str:
-    """
-    Get transfer statistics for a specific player in a specific gameweek.
-
-    Shows transfers in, transfers out, net transfers, ownership data, and performance.
-    Useful for understanding how manager sentiment towards a player changed during a
-    specific gameweek and correlation with performance.
-
-    Args:
-        params (GetPlayerTransfersByGameweekInput): Validated input parameters containing:
-            - player_name (str): Player name (e.g., 'Haaland', 'Salah')
-            - gameweek (int): Gameweek number between 1-38
-
-    Returns:
-        str: Transfer statistics and performance for the gameweek
-
-    Examples:
-        - Check Haaland GW20: player_name="Haaland", gameweek=20
-        - Salah transfers: player_name="Salah", gameweek=15
-
-    Error Handling:
-        - Returns error if player not found
-        - Suggests using fpl_find_player if name ambiguous
-        - Returns error if no data for gameweek
-    """
-    try:
-        client = await _create_client()
-
-        # Find player by name
-        matches = store.find_players_by_name(params.player_name, fuzzy=True)
-        if not matches:
-            return f"No player found matching '{params.player_name}'. Use fpl_search_players to find the correct name."
-
-        if len(matches) > 1 and matches[0][1] < 0.95:
-            return f"Ambiguous player name. Use fpl_find_player to see all matches for '{params.player_name}'"
-
-        player = matches[0][0]
-        player_id = player.id
-
-        # Fetch detailed summary from API
-        summary_data = await client.get_element_summary(player_id)
-        history = summary_data.get("history", [])
-
-        # Find the specific gameweek in history
-        gw_data = next((gw for gw in history if gw.get("round") == params.gameweek), None)
-
-        if not gw_data:
-            return f"No transfer data found for {player.web_name} in gameweek {params.gameweek}. The gameweek may not have started yet or data is unavailable."
-
-        # Enrich with team name
-        enriched_history = store.enrich_gameweek_history([gw_data])
-        if enriched_history:
-            gw_data = enriched_history[0]
-
-        output = [
-            f"**{player.web_name}** ({player.first_name} {player.second_name})",
-            f"Team: {player.team_name} | Position: {player.position} | Price: {format_player_price(player.now_cost)}",
-            "",
-            f"**Gameweek {params.gameweek} Transfer Statistics:**",
-            "",
-            f"├─ Transfers In: {gw_data.get('transfers_in', 0):,}",
-            f"├─ Transfers Out: {gw_data.get('transfers_out', 0):,}",
-            f"├─ Net Transfers: {gw_data.get('transfers_balance', gw_data.get('transfers_in', 0) - gw_data.get('transfers_out', 0)):+,}",
-            f"├─ Ownership at GW: {gw_data.get('selected', 0):,} teams",
-            "",
-            f"**Performance in GW{params.gameweek}:**",
-            f"├─ Points: {gw_data.get('total_points', 0)}",
-            f"├─ Minutes: {gw_data.get('minutes', 0)}",
-            f"├─ xGoal: {gw_data.get('expected_goals', '0.00')} | Goals: {gw_data.get('goals_scored', 0)}",
-            f"├─ xAssist: {gw_data.get('expected_assists', '0.00')} | Assists: {gw_data.get('assists', 0)}",
-            f"├─ Clean Sheets: {gw_data.get('clean_sheets', 0)} | Bonus: {gw_data.get('bonus', 0)}",
-        ]
-
-        opponent_name = gw_data.get("opponent_team_short", "Unknown")
-        home_away = "H" if gw_data.get("was_home") else "A"
-        output.append(f"├─ Opponent: vs {opponent_name} ({home_away})")
-
-        result = "\n".join(output)
-        truncated, _ = check_and_truncate(result, CHARACTER_LIMIT)
-        return truncated
-
-    except Exception as e:
-        return handle_api_error(e)
-
-
 @mcp.tool(
     name="fpl_get_top_transferred_players",
     annotations={
@@ -611,3 +526,226 @@ async def fpl_get_manager_chips(params: GetManagerChipsInput) -> str:
 
     except Exception as e:
         return handle_api_error(e)
+
+
+@mcp.tool(
+    name="fpl_analyze_transfer",
+    annotations={
+        "title": "Analyze FPL Transfer",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": True,
+    },
+)
+async def fpl_analyze_transfer(params: AnalyzeTransferInput) -> str:
+    """
+    Analyze a potential transfer decision between two players.
+
+    Compares the player being transferred out vs the player being transferred in.
+    Analyzes form, upcoming fixtures (next 5), price difference, and overall value.
+    Provides a direct recommendation based on the data.
+
+    Args:
+        params (AnalyzeTransferInput): Validated input parameters containing:
+            - player_out (str): Name of player to remove
+            - player_in (str): Name of player to add
+            - my_team_id (int | None): Optional team ID to check budget impact
+
+    Returns:
+        str: Detailed transfer analysis and recommendation
+
+    Examples:
+        - Analyze move: player_out="Salah", player_in="Palmer"
+        - Check budget: player_out="Saka", player_in="Foden", my_team_id=123456
+
+    Error Handling:
+        - Returns error if either player not found
+        - Returns error if players play different positions (unless specified)
+        - Returns formatted error message if API fails
+    """
+    try:
+        client = await _create_client()
+        if not store.bootstrap_data:
+            return "Error: Player data not available. Please try again later."
+
+        # Helper to find player
+        def find_player(name):
+            matches = store.find_players_by_name(name, fuzzy=True)
+            if not matches:
+                return None, f"Player '{name}' not found."
+            if (
+                len(matches) > 1
+                and matches[0][1] < 0.95
+                and not (matches[0][1] - matches[1][1] > 0.2)
+            ):
+                return (
+                    None,
+                    f"Ambiguous name '{name}'. Did you mean: {', '.join(m[0].web_name for m in matches[:3])}?",
+                )
+            return matches[0][0], None
+
+        # Find both players
+        p_out, err_out = find_player(params.player_out)
+        if err_out:
+            return f"Error finding player_out: {err_out}"
+
+        p_in, err_in = find_player(params.player_in)
+        if err_in:
+            return f"Error finding player_in: {err_in}"
+
+        # Check positions
+        pos_names = {1: "GKP", 2: "DEF", 3: "MID", 4: "FWD"}
+        if p_out.element_type != p_in.element_type:
+            # element_type 1=GKP, 2=DEF, 3=MID, 4=FWD
+            # Get position names
+            return (
+                f"Invalid transfer: {p_out.web_name} is a {pos_names.get(p_out.element_type)} "
+                f"while {p_in.web_name} is a {pos_names.get(p_in.element_type)}. "
+                f"Transfers must be between players of the same position."
+            )
+
+        # Get fixtures for next 5 gameweeks
+        current_gw_data = store.get_current_gameweek()
+        start_gw = (current_gw_data.id + 1) if current_gw_data else 1
+        # Handle case where season is over
+        if start_gw > 38:
+            start_gw = 38
+
+        # Fetch detailed summaries for both
+        summary_out = await client.get_element_summary(p_out.id)
+        summary_in = await client.get_element_summary(p_in.id)
+
+        # Process Fixtures
+        fixtures_out = store.enrich_fixtures(summary_out.get("fixtures", []))
+        fixtures_in = store.enrich_fixtures(summary_in.get("fixtures", []))
+
+        # Filter next 5 fixtures
+        next_5_out = [f for f in fixtures_out if f["event"] and f["event"] >= start_gw][:5]
+        next_5_in = [f for f in fixtures_in if f["event"] and f["event"] >= start_gw][:5]
+
+        # Calculate difficulty score (lower is easier)
+        def calc_difficulty(fixtures, is_attacker):
+            total = 0
+            count = 0
+            for f in fixtures:
+                diff = (
+                    f.get("team_h_difficulty") if f.get("is_home") else f.get("team_a_difficulty")
+                )
+                if diff is None:
+                    diff = 3  # Default to average if missing
+                total += int(diff)
+                count += 1
+            return total / count if count > 0 else 0
+
+        # Heuristic: MIDs and FWDs are attackers, DEF and GKP defenders
+        is_attacker = p_out.element_type in [3, 4]
+        diff_out = calc_difficulty(next_5_out, is_attacker)
+        diff_in = calc_difficulty(next_5_in, is_attacker)
+
+        # Calculate budget impact
+        price_diff = p_in.now_cost - p_out.now_cost
+
+        if params.response_format == ResponseFormat.JSON:
+            result = {
+                "transfer": {
+                    "out": p_out.web_name,
+                    "in": p_in.web_name,
+                    "position": p_out.position,
+                },
+                "analysis": {
+                    "price_change": price_diff / 10,
+                    "fixture_diff_score": {
+                        "out": round(diff_out, 2),
+                        "in": round(diff_in, 2),
+                        "easier_fixtures": "in" if diff_in < diff_out else "out",
+                    },
+                    "form": {"out": float(p_out.form), "in": float(p_in.form)},
+                    "points_per_game": {
+                        "out": float(p_out.points_per_game),
+                        "in": float(p_in.points_per_game),
+                    },
+                },
+                "recommendation": "TRANSFER IN"
+                if diff_in < diff_out and float(p_in.form) > float(p_out.form)
+                else "HOLD",
+            }
+            return format_json_response(result)
+
+        # Markdown Output
+        output = [
+            f"## Transfer Analysis: {p_out.web_name} ➔ {p_in.web_name}",
+            f"**Position:** {pos_names.get(p_out.element_type)} | **Budget Impact:** {format_player_price(price_diff)}",
+            "",
+            "### 📊 Head-to-Head Comparison",
+            f"| Metric | ❌ {p_out.web_name} (OUT) | ✅ {p_in.web_name} (IN) | Diff |",
+            "| :--- | :--- | :--- | :--- |",
+            f"| **Price** | {format_player_price(p_out.now_cost)} | {format_player_price(p_in.now_cost)} | {format_player_price(price_diff)} |",
+            f"| **Form** | {p_out.form} | {p_in.form} | {float(p_in.form) - float(p_out.form):.1f} |",
+            f"| **PPG** | {p_out.points_per_game} | {p_in.points_per_game} | {float(p_in.points_per_game) - float(p_out.points_per_game):.1f} |",
+            f"| **Total Pts** | {getattr(p_out, 'total_points', 0)} | {getattr(p_in, 'total_points', 0)} | {getattr(p_in, 'total_points', 0) - getattr(p_out, 'total_points', 0)} |",
+            f"| **Ownership** | {getattr(p_out, 'selected_by_percent', '0.0')}% | {getattr(p_in, 'selected_by_percent', '0.0')}% | {float(getattr(p_in, 'selected_by_percent', '0.0')) - float(getattr(p_out, 'selected_by_percent', '0.0')):+.1f}% |",
+            "",
+            "### 🗓️ Upcoming Fixtures (Next 5)",
+            "Lower difficulty score is better (easier fixtures).",
+            "",
+            f"**{p_out.web_name}** (Avg Diff: {diff_out:.2f})",
+        ]
+
+        # Helper to format fixture string
+        def format_fixture(f):
+            opp = f.get("team_a_short") if f.get("is_home") else f.get("team_h_short")
+            if not opp:
+                opp = "UNK"
+            diff = f.get("difficulty", "?")
+            loc = "H" if f.get("is_home") else "A"
+            return f"{opp} ({loc}) [{diff}]"
+
+        # Format fixtures
+        out_fixtures_str = " | ".join([format_fixture(f) for f in next_5_out])
+        output.append(f"└─ {out_fixtures_str}")
+
+        output.append("")
+        output.append(f"**{p_in.web_name}** (Avg Diff: {diff_in:.2f})")
+        in_fixtures_str = " | ".join([format_fixture(f) for f in next_5_in])
+        output.append(f"└─ {in_fixtures_str}")
+
+        output.append("")
+        output.append("### 💡 Recommendation")
+
+        # Simple Logic
+        better_fixtures = diff_in < diff_out
+        better_form = float(p_in.form) > float(p_out.form)
+        cheaper = price_diff < 0
+
+        score = 0
+        if better_fixtures:
+            score += 2
+        if better_form:
+            score += 1
+        if cheaper:
+            score += 0.5
+        if float(p_in.points_per_game) > float(p_out.points_per_game):
+            score += 1
+
+        if score >= 3:
+            output.append(
+                f"✅ **Recommended Transfer** - {p_in.web_name} is a strong upgrade with better fixtures and stats."
+            )
+        elif score >= 1.5:
+            output.append(
+                f"⚖️ **Consider Transfer** - {p_in.web_name} has some advantages, but it's close."
+            )
+        else:
+            output.append(
+                f"🛑 **Hold Transfer** - {p_out.web_name} looks like the better hold right now."
+            )
+
+        # Add availability check
+        if p_in.status != "a":
+            output.append(f"\n⚠️ **Warning:** {p_in.web_name} is currently flagged: {p_in.news}")
+
+        return "\n".join(output)
+
+    except Exception as e:
+        return handle_api_error(e)

fpl_mcp_server-0.1.6.dist-info/RECORD

@@ -1,35 +0,0 @@
-src/cache.py,sha256=SeJAmddaY9507Ac5YRnbBBXGOQw_OwpIefB-kn11lDI,4604
-src/client.py,sha256=_Tv7TlXD5d3pvXb7AmMCgy3gbZqjOO9EedMORveRU4s,10493
-src/config.py,sha256=hfjW-W0gdH0PxmC6gEg-o9SqraajJ6gNy1SIlIOG-F4,845
-src/constants.py,sha256=8XkQH1rslnf6VWbJkVY6MmpgRhhS3wjFJhIoZWr91kg,839
-src/exceptions.py,sha256=Q8waMbF8Sr1s6lOoAB8-doX0v6EvqZopwQHGxNQ7m-w,2972
-src/formatting.py,sha256=aLiJWM2hJw68gyGJ1Nc1nPAyfoSIqwyjPE8svr-7ufo,10236
-src/main.py,sha256=C6wX96rm0-b1jSvU2BrTv47hw2FGktkwcqJ5nEM8t5U,977
-src/models.py,sha256=P5rIO-UjVQpLUlDQsDV5hw2Tn3s5Xcj6ye8xJkRizGc,10880
-src/rate_limiter.py,sha256=GLk3ZRFFvEZxkZAQd-pZ7UxQdrAAUVch3pxe_aMU-J8,3450
-src/state.py,sha256=seyygRhlz-K1GtG80os34tnNJ6UkAFA2rVFgupZG2tY,17531
-src/utils.py,sha256=WhcWQIXpc1vIjU8hyrGDJyKJSlcbVoG938k_3UMDlCM,7340
-src/validators.py,sha256=aU36TUNYWb26fvZH27Xnryrp8gve9DM2phvy7vEnAi8,6891
-src/prompts/__init__.py,sha256=Sj7YgIL46wGrmkJq39rpJilPK3blK6oPI-hE2-lBdxY,535
-src/prompts/captain_recommendation.py,sha256=2UK4NQMKL8n1m7gLeebkEDhzndGuJXQBt1FLfS1oo2Y,5850
-src/prompts/chips.py,sha256=zzv5bqr8HuUAkvXenonrTXVhwNYGMwH9OPSC-c-1Dtg,5524
-src/prompts/league_analysis.py,sha256=23rNhCYkU8hSmd5BesXgNgHLFo_B8qgszmw909MPHkA,8095
-src/prompts/player_analysis.py,sha256=SGyd0UYWMF0lgml9idfc853UHgXXBT_qLVLf-8PFePU,5242
-src/prompts/squad_analysis.py,sha256=7ixTIrvTITvLIE-9ATH744ci_pObWgzx3p5yUqVHmEk,5204
-src/prompts/team_analysis.py,sha256=lZZ2R1xlsclwy4UyiokMg41ziuCKAqxgN_CoT1mOvnY,4104
-src/prompts/team_selection.py,sha256=tDOiyQYTp-hyKlKVAdjGxZsr1xPfMgApWREjbMtNpXM,3847
-src/prompts/transfers.py,sha256=B99xjzJDTRRdwMluANjKxr5DPWB6eg69nZqJ5uyTosA,5448
-src/resources/__init__.py,sha256=i7nlLVSLtiIrLtOnyoMiK3KTFGEnct4LXApB4b6URFM,303
-src/resources/bootstrap.py,sha256=ViZsGYtr5YqiTtvM_YTkbCr6R6Z9vUBiVSGGI9wwI3s,6970
-src/tools/__init__.py,sha256=JjoMoMHrhFRMarpgtOS9AoS9604c0p-yFc0PXoITe-E,510
-src/tools/fixtures.py,sha256=rbt565LV4C_gXfM9tTGUKqMRGl-a_jXcOKZ1tVCXkrA,5634
-src/tools/gameweeks.py,sha256=wylGJAXSXhmSy7-PdoXm-w4i4jQIXkSaqM27ctK6w_o,14859
-src/tools/leagues.py,sha256=tW6FDjLf7pSWjGgsxCCMAyOpHvSxpBfYXxyaNtHQiLU,30308
-src/tools/players.py,sha256=9UX1fZJbiUUDBFBMeImcIh8ysIfc1NQV21_298yX1cU,30568
-src/tools/teams.py,sha256=wEbLHKivvGw5YhO0tyvxhUMR9nsYyb4-BQWNBbnzGTw,14183
-src/tools/transfers.py,sha256=kU7xy3d6wDZ4T38gNIg6UBJWkfh9-fYhasY_uXR7qGE,24021
-fpl_mcp_server-0.1.6.dist-info/METADATA,sha256=Pc1pmqRKBJE1ZyRH5IbL_jChwplQ91-hAaFOAwQzgyg,4788
-fpl_mcp_server-0.1.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-fpl_mcp_server-0.1.6.dist-info/entry_points.txt,sha256=b3R5hBUMTLVnCGl07NfK7kyq9NCKtpn5Q8OsY79pMek,49
-fpl_mcp_server-0.1.6.dist-info/licenses/LICENSE,sha256=HCDOcdX83voRU2Eip214yj6P_tEyjVjCsCW_sixZFPw,1071
-fpl_mcp_server-0.1.6.dist-info/RECORD,,