fcode 2.2.0__cp313-cp313-win_amd64.whl

fcode/commands/match_detail.py

@@ -0,0 +1,173 @@
+"""fcode match — view detailed match info including individual games."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from fcode.api import api_get
+
+console = Console()
+
+_STAGE_LABELS = {
+    "starting": "Starting...",
+    "downloading_bots": "Downloading bots...",
+    "uploading_replay": "Uploading replay...",
+    "processing_result": "Processing...",
+}
+
+_CONDITION_LABELS = {
+    "core_destroyed": "Core Destroyed",
+    "resigned": "Resigned",
+    "resources": "Resource Victory",
+    "titanium_collected": "Titanium Collected",
+    "harvesters": "Harvesters",
+    "titanium_stored": "Titanium Stored",
+    "coinflip": "Coinflip",
+    "timeout": "Timeout",
+    "error": "Error",
+}
+
+
+def _format_stage(stage: str) -> str:
+    if stage in _STAGE_LABELS:
+        return _STAGE_LABELS[stage]
+    if stage.startswith("running_game_"):
+        n = stage.split("_")[2]
+        return f"Game {n}/5"
+    return stage
+
+
+def _show_match_detail(match_id: str):
+    """Core implementation for showing match detail."""
+    data = api_get(f"/api/matches/{match_id}")
+    m = data.get("match")
+    games = data.get("games", [])
+
+    if not m:
+        console.print("[red]Match not found.[/red]")
+        raise SystemExit(1)
+
+    status = m.get("status", "?")
+    triggered = m.get("triggeredBy", "?")
+    rated = "rated" if m.get("rated") else "unrated"
+    score = f"{m.get('scoreA', 0)}-{m.get('scoreB', 0)}"
+
+    console.print(f"\n[bold]Match {match_id}[/bold]")
+
+    stage = m.get("stage") or ""
+    if status == "complete":
+        status_display = f"[green]{status}[/green]"
+    elif status == "error":
+        status_display = f"[red]{status}[/red]"
+    elif status == "running":
+        stage_label = _format_stage(stage) if stage else ""
+        status_display = f"[yellow]{status}[/yellow]"
+        if stage_label:
+            status_display += f" ({stage_label})"
+    elif status == "queued":
+        status_display = f"[dim]{status}[/dim]"
+    else:
+        status_display = status
+    console.print(f"  Status:  {status_display}")
+    console.print(f"  Type:    {triggered} ({rated})")
+
+    team_a = m.get("teamAName") or "Bot A"
+    team_b = m.get("teamBName") or "Bot B"
+    team_a_id = m.get("teamAId")
+    team_b_id = m.get("teamBId")
+    winner_id = m.get("winnerId")
+
+    score_a = m.get("scoreA", 0)
+    score_b = m.get("scoreB", 0)
+    a_is_winner = (winner_id and winner_id == team_a_id) or (not winner_id and score_a > score_b)
+    b_is_winner = (winner_id and winner_id == team_b_id) or (not winner_id and score_b > score_a)
+
+    a_id_display = f" ({team_a_id})" if team_a_id else ""
+    a_line = f"  Team A:  [bold]{team_a}[/bold]{a_id_display}"
+    if a_is_winner:
+        a_line += " [green]<- winner[/green]"
+    source_a = m.get("sourceMatchAId")
+    if source_a:
+        a_line += f"\n           [dim]submission from match {source_a}[/dim]"
+
+    b_id_display = f" ({team_b_id})" if team_b_id else ""
+    b_line = f"  Team B:  [bold]{team_b}[/bold]{b_id_display}"
+    if b_is_winner:
+        b_line += " [green]<- winner[/green]"
+    source_b = m.get("sourceMatchBId")
+    if source_b:
+        b_line += f"\n           [dim]submission from match {source_b}[/dim]"
+
+    console.print(a_line)
+    console.print(b_line)
+    console.print(f"  Score:   [bold]{score}[/bold]")
+
+    elo_a = m.get("eloDeltaA")
+    elo_b = m.get("eloDeltaB")
+    if elo_a is not None and elo_b is not None:
+        sign_a = "+" if elo_a >= 0 else ""
+        sign_b = "+" if elo_b >= 0 else ""
+        console.print(f"  ELO:     A: {sign_a}{elo_a:.1f}  B: {sign_b}{elo_b:.1f}")
+
+    created = m.get("createdAt", "")
+    if created:
+        console.print(f"  Created: {created[:19].replace('T', ' ')}")
+    completed = m.get("completedAt", "")
+    if completed:
+        console.print(f"  Done:    {completed[:19].replace('T', ' ')}")
+
+    error_msg = m.get("errorMessage")
+    if error_msg:
+        # Decode escaped newlines/tabs from the stored error string
+        rendered = error_msg.replace("\\n", "\n").replace("\\t", "\t")
+        console.print()
+        if status == "error":
+            console.print("[red]Error:[/red]")
+            for line in rendered.splitlines():
+                console.print(f"  [red]{line}[/red]")
+        else:
+            console.print(f"  [dim]{rendered}[/dim]")
+
+    if not games:
+        if status == "queued":
+            console.print("\n  [dim]Match is queued — waiting for a runner...[/dim]\n")
+        elif status == "running":
+            console.print("\n  [dim]Match is running...[/dim]\n")
+        else:
+            console.print("\n  [dim]No game data.[/dim]\n")
+        return
+
+    console.print()
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("#", justify="right")
+    table.add_column("Map")
+    table.add_column("Winner", justify="center")
+    table.add_column("Condition")
+    table.add_column("Turns", justify="right")
+
+    for g in games:
+        game_num = str(g.get("gameNumber", "?"))
+        map_name = g.get("mapName", "?")
+        g_winner = g.get("winnerId")
+
+        if g_winner and g_winner == team_a_id:
+            winner = f"[green]A ({team_a})[/green]"
+        elif g_winner and g_winner == team_b_id:
+            winner = f"[green]B ({team_b})[/green]"
+        else:
+            winner = "[dim]--[/dim]"
+
+        raw_condition = g.get("winCondition", "?")
+        condition = _CONDITION_LABELS.get(raw_condition, raw_condition)
+        turns = str(g.get("turnsPlayed", "?"))
+        table.add_row(game_num, map_name, winner, condition, turns)
+
+    console.print(table)
+    console.print()
+
+
+@click.command("match")
+@click.argument("match_id")
+def match_detail(match_id: str):
+    """View detailed info for a match, including individual games."""
+    _show_match_detail(match_id)

fcode/commands/match_group.py

@@ -0,0 +1,163 @@
+"""fcode match — view, list, and manage matches."""
+
+import click
+from rich.console import Console
+
+from fcode.compat import SmartGroup
+
+console = Console()
+
+
+@click.group(cls=SmartGroup, default_cmd="info")
+def match():
+    """View, list, and manage matches."""
+    pass
+
+
+# --- info (default subcommand) ---
+from fcode.commands.match_detail import _show_match_detail
+
+
+@match.command()
+@click.argument("match_id")
+def info(match_id: str):
+    """View detailed info for a match, including individual games."""
+    _show_match_detail(match_id)
+
+
+# --- list ---
+from fcode.commands.matches import _show_matches
+
+
+@match.command("list")
+@click.option(
+    "--type",
+    "match_type",
+    default=None,
+    type=click.Choice(["ladder", "unrated"]),
+    help="Filter by match type (shows all if omitted)",
+)
+@click.option("--team", default=None, help="Filter by team name or team ID")
+@click.option("--mine", is_flag=True, help="Show only your team's matches")
+@click.option("--limit", default=20, type=int, help="Number of matches to show (max 100)")
+@click.option("--cursor", default=None, help="Pagination cursor (from previous page)")
+def list_matches(match_type, team, mine, limit, cursor):
+    """List recent matches. Use --type to filter by ladder or unrated."""
+    _show_matches(match_type, team, limit, cursor, mine=mine)
+
+
+# --- unrated ---
+from fcode.commands.test import _show_unrated
+
+
+@match.command()
+@click.argument("opponent_id")
+@click.option("--match", "source_match", default=None, help="Use opponent's submission from this match ID")
+@click.option("--map", "maps", multiple=True, help="Map name (repeatable, up to 5). Omit for random.")
+def unrated(opponent_id: str, source_match: str | None, maps: tuple[str, ...]):
+    """Request an unrated match against OPPONENT_ID.
+
+    Use `fcode team search` to find team IDs.
+
+    With --map, specify which maps to play (up to 5). Omit for random selection.
+    Example: fcode match unrated <id> --map arena --map fortress
+    """
+    _show_unrated(opponent_id, source_match, maps if maps else None)
+
+
+# --- test ---
+from fcode.commands.test_run import _show_test_run
+
+
+@match.command("test")
+@click.argument("bot_a")
+@click.argument("bot_b")
+@click.argument("maps", nargs=-1)
+def test(bot_a: str, bot_b: str, maps: tuple[str, ...]):
+    """Run a remote test match between two local bots with TLE enforcement.
+
+    \b
+    BOT_A and BOT_B can be directories (containing main.py), single .py files,
+    or .zip archives.
+    MAPS are optional .map26 files — one per game. If omitted, 5 random maps.
+    """
+    _show_test_run(bot_a, bot_b, maps)
+
+
+# --- replay ---
+
+@match.command()
+@click.argument("match_id")
+@click.option("--game", "-g", default=None, type=int, help="Game number (1-5). Downloads all if omitted.")
+@click.option("--output", "-o", default=None, help="Output file path (default: <matchId>_game_<N>.replay26)")
+def replay(match_id: str, game: int | None, output: str | None):
+    """Download replay file(s) for a match.
+
+    Downloads .replay26 files locally for offline viewing with `fcode watch`.
+    """
+    import urllib.request
+    from fcode.api import api_get
+
+    # Get match games to know how many there are
+    data = api_get(f"/api/matches/{match_id}")
+    games = data.get("games", [])
+
+    if not games:
+        console.print("[red]No games found for this match (match may still be running).[/red]")
+        raise SystemExit(1)
+
+    if game is not None:
+        targets = [g for g in games if g.get("gameNumber") == game]
+        if not targets:
+            console.print(f"[red]Game {game} not found. Match has games 1-{len(games)}.[/red]")
+            raise SystemExit(1)
+    else:
+        targets = games
+
+    for g in targets:
+        gn = g.get("gameNumber", 0)
+        replay_data = api_get("/api/matches/replay", {"matchId": match_id, "game": str(gn)})
+        url = replay_data.get("url")
+        if not url:
+            console.print(f"  [yellow]Game {gn}: no replay available[/yellow]")
+            continue
+
+        if output and len(targets) == 1:
+            out_path = output
+        else:
+            out_path = f"{match_id}_game_{gn}.replay26"
+
+        urllib.request.urlretrieve(url, out_path)
+        console.print(f"  [green]Game {gn}:[/green] {out_path}")
+
+    console.print(f"\n[dim]View with: fcode watch <file>[/dim]")
+
+
+# --- watch ---
+
+@match.command("watch")
+@click.argument("match_id")
+@click.option("--game", "-g", default=None, type=int, help="Game number within match")
+def watch(match_id: str, game: int | None):
+    """Open a match replay in the visualizer (browser).
+
+    Shortcut for `fcode watch --match <id>`.
+    """
+    from fcode.auth import get_api_url
+    import webbrowser
+
+    url = f"{get_api_url()}/visualiser?matchId={match_id}"
+    if game is not None:
+        url += f"&game={game}"
+    webbrowser.open(url)
+
+
+# --- tests ---
+from fcode.commands.test_matches import _show_test_matches
+
+
+@match.command("tests")
+@click.option("--limit", default=20, type=int, help="Number of test runs to show")
+def tests(limit: int):
+    """List your remote test run matches."""
+    _show_test_matches(limit)

fcode/commands/matches.py

@@ -0,0 +1,127 @@
+"""fcode matches — list and filter matches."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from fcode.api import api_get
+from fcode.auth import load_credentials
+
+console = Console()
+
+
+def _show_matches(match_type: str | None, team: str | None, limit: int, cursor: str | None, mine: bool = False):
+    """Core implementation for listing matches."""
+    params: dict[str, str | list[str]] = {"limit": str(min(limit, 100))}
+    if match_type:
+        params["type"] = match_type
+    if mine and not team:
+        creds = load_credentials()
+        if creds and creds.get("team"):
+            params["teamIds"] = creds["team"]["id"]
+        else:
+            console.print("[red]Not on a team. Use --team instead.[/red]")
+            raise SystemExit(1)
+    elif team:
+        # Try to resolve team name to ID via search
+        search_data = api_get("/api/teams/search", {"q": team})
+        search_results = search_data.get("teams", [])
+        # Check for exact match first, then fall back to first result
+        exact = [t for t in search_results if t["teamName"].lower() == team.lower()]
+        if exact:
+            params["teamIds"] = exact[0]["teamId"]
+        elif search_results:
+            params["teamIds"] = search_results[0]["teamId"]
+        else:
+            # Maybe it's already a team ID
+            params["teamIds"] = team
+    if cursor:
+        params["cursor"] = cursor
+
+    data = api_get("/api/matches", params)
+    match_list = data.get("matches", [])
+    next_cursor = data.get("nextCursor")
+
+    if not match_list:
+        label = match_type or "all"
+        console.print(f"[dim]No {label} matches found.[/dim]")
+        return
+
+    creds = load_credentials()
+    my_team_id = None
+    if creds and creds.get("team"):
+        my_team_id = creds["team"].get("id")
+
+    show_type = match_type is None
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Match ID", style="dim")
+    if show_type:
+        table.add_column("Type", style="dim")
+    table.add_column("Team A")
+    table.add_column("Score", justify="center")
+    table.add_column("Team B")
+    table.add_column("Status")
+    table.add_column("Date", style="dim")
+
+    for m in match_list:
+        team_a_name = m.get("teamAName", "?")
+        team_b_name = m.get("teamBName", "?")
+        team_a_id = m.get("teamAId", "")
+        team_b_id = m.get("teamBId", "")
+
+        if m.get("sourceMatchAId"):
+            team_a_name += " [dim](OLD)[/dim]"
+        if m.get("sourceMatchBId"):
+            team_b_name += " [dim](OLD)[/dim]"
+
+        if my_team_id and team_a_id == my_team_id:
+            team_a_name = f"[bold]{team_a_name}[/bold]"
+        if my_team_id and team_b_id == my_team_id:
+            team_b_name = f"[bold]{team_b_name}[/bold]"
+
+        winner_id = m.get("winnerId")
+        if winner_id == team_a_id:
+            team_a_name = f"[green]{team_a_name}[/green]"
+            team_b_name = f"[red]{team_b_name}[/red]"
+        elif winner_id == team_b_id:
+            team_a_name = f"[red]{team_a_name}[/red]"
+            team_b_name = f"[green]{team_b_name}[/green]"
+
+        score = f"{m.get('scoreA', 0)}-{m.get('scoreB', 0)}"
+        status = m.get("status", "?")
+        match_id = m.get("id", "?")
+
+        date = ""
+        raw_date = m.get("completedAt") or m.get("createdAt")
+        if raw_date:
+            date = raw_date[:16].replace("T", " ")
+
+        row: list[str] = [match_id]
+        if show_type:
+            triggered = m.get("triggeredBy", "?")
+            row.append("UR" if triggered == "unrated" else triggered)
+        row.extend([team_a_name, score, team_b_name, status, date])
+        table.add_row(*row)
+
+    console.print(table)
+
+    if next_cursor:
+        console.print(f"\n[dim]More results available. Use --cursor '{next_cursor}'[/dim]")
+
+
+@click.command()
+@click.option(
+    "--type",
+    "match_type",
+    default=None,
+    type=click.Choice(["ladder", "unrated"]),
+    help="Filter by match type (shows all if omitted)",
+)
+@click.option("--team", default=None, help="Filter by team name or team ID")
+@click.option("--mine", is_flag=True, help="Show only your team's matches")
+@click.option("--limit", default=20, type=int, help="Number of matches to show (max 100)")
+@click.option("--cursor", default=None, help="Pagination cursor (from previous page)")
+def matches(match_type: str | None, team: str | None, mine: bool, limit: int, cursor: str | None):
+    """List recent matches. Use --type to filter by ladder or unrated."""
+    _show_matches(match_type, team, limit, cursor, mine=mine)

fcode/commands/run.py

@@ -0,0 +1,186 @@
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from fcode.config import find_config
+
+console = Console()
+
+
+def _print_summary(console: Console, result: dict, name_a: str, name_b: str):
+    winner = result["winner"]
+    turns = result["turns"]
+    condition = result["win_condition"]
+    resign_message = result.get("resign_message")
+
+    condition_labels = {
+        "core_destroyed": "Core destroyed",
+        "resigned": "Resigned",
+        "resources": "Resources (tiebreak)",
+        "titanium_collected": "Titanium collected (tiebreak)",
+        "harvesters": "Harvesters (tiebreak)",
+        "titanium_stored": "Titanium stored (tiebreak)",
+        "coinflip": "Coinflip (tiebreak)",
+        "timeout": "Draw",
+    }
+    reason = condition_labels.get(condition, condition)
+
+    if winner == "A":
+        winner_name = name_a
+        winner_style = "[bold green]"
+    elif winner == "B":
+        winner_name = name_b
+        winner_style = "[bold green]"
+    else:
+        winner_name = "Draw"
+        winner_style = "[bold yellow]"
+
+    console.print()
+    console.print(f"  {winner_style}Winner: {winner_name}[/]  [dim]({reason}, turn {turns})[/dim]")
+    if resign_message:
+        console.print(f"  [dim italic]Resign message: {resign_message}[/dim italic]")
+    console.print()
+
+    # Resource table
+    from rich.table import Table
+    t = Table(show_header=True, box=None, padding=(0, 2))
+    t.add_column("", style="dim")
+    a_style = "bold" if winner == "A" else ""
+    b_style = "bold" if winner == "B" else ""
+    t.add_column(name_a, justify="right", style=a_style)
+    t.add_column(name_b, justify="right", style=b_style)
+    t.add_row(
+        "Titanium",
+        f"{result['a_titanium']} ({result['a_titanium_collected']} mined)",
+        f"{result['b_titanium']} ({result['b_titanium_collected']} mined)",
+    )
+    t.add_row("Units", str(result["a_units"]), str(result["b_units"]))
+    t.add_row("Buildings", str(result["a_buildings"]), str(result["b_buildings"]))
+    console.print(t)
+    console.print()
+
+
+def resolve_map_path(path_str: str, maps_dir: Path) -> Path:
+    """Resolve a map path. Tries: raw path, maps_dir/path, path+.map26, maps_dir/path+.map26."""
+    p = Path(path_str)
+    if p.exists():
+        return p
+
+    if not p.is_absolute():
+        # Try maps_dir/path
+        candidate = maps_dir / path_str
+        if candidate.exists():
+            return candidate
+        # Try adding .map26 extension
+        if not path_str.endswith(".map26"):
+            with_ext = Path(path_str + ".map26")
+            if with_ext.exists():
+                return with_ext
+            candidate_ext = maps_dir / (path_str + ".map26")
+            if candidate_ext.exists():
+                return candidate_ext
+
+    return p  # Return as-is; caller will get a file-not-found naturally
+
+
+def resolve_bot_path(path_str: str, bots_dir: Path) -> str:
+    """Resolve a bot path. Checks raw path first, then bots_dir/path."""
+    p = Path(path_str)
+
+    # If it's already a valid path, use it directly
+    if not p.exists() and not p.is_absolute():
+        # Try resolving relative to bots_dir
+        candidate = bots_dir / path_str
+        if candidate.exists():
+            p = candidate
+
+    if p.is_dir():
+        main_py = p / "main.py"
+        if main_py.is_file():
+            return str(main_py.resolve())
+        raise click.BadParameter(
+            f"Directory '{path_str}' does not contain main.py"
+        )
+    if p.is_file():
+        return str(p.resolve())
+    raise click.BadParameter(f"Bot not found: '{path_str}'")
+
+
+@click.command()
+@click.argument("bot_a")
+@click.argument("bot_b")
+@click.argument("map_path", required=False, default=None)
+@click.option("--replay", default=None, help="Output replay path")
+@click.option("--seed", default=None, type=int)
+@click.option("--watch", "auto_watch", is_flag=True, help="Open visualizer after match")
+@click.option("--tle", default=0, type=int, help="Turn time limit in ms (0 to disable, server uses 10)")
+@click.option("--map-random", is_flag=True, help="Pick a random map from maps directory")
+def run(bot_a: str, bot_b: str, map_path: str | None, replay: str | None, seed: int | None, auto_watch: bool, tle: int, map_random: bool):
+    """Run a local match between two bots.
+
+    MAP_PATH is optional — if omitted, uses the first .map26 file in the maps directory.
+    """
+    from fcode.fcode_engine import run_game
+
+    config, project_root = find_config()
+
+    # Apply config defaults where CLI didn't override
+    replay = replay or config.replay
+    seed = seed if seed is not None else config.seed
+    bots_dir = (project_root / config.bots_dir).resolve()
+    maps_dir = (project_root / config.maps_dir).resolve()
+
+    # Game types are re-exported in fcode/__init__.py via _types.py,
+    # so `from fcode import *` already works. engine_root is passed to the
+    # Rust engine for sys.path setup (redundant here, needed by server binary).
+    engine_root = str(Path(__file__).resolve().parent.parent)
+
+    player_a = resolve_bot_path(bot_a, bots_dir)
+    player_b = resolve_bot_path(bot_b, bots_dir)
+
+    # Resolve map — pick first (or random) if not specified
+    if map_path is None:
+        maps = sorted(maps_dir.glob("*.map26"))
+        if not maps:
+            console.print("[red]No .map26 files found in maps/ directory. Provide a map path.[/red]")
+            raise SystemExit(1)
+        if map_random:
+            import random
+            mp = random.choice(maps)
+        else:
+            mp = maps[0]
+    else:
+        mp = resolve_map_path(map_path, maps_dir)
+    resolved_map = str(mp.resolve())
+
+    name_a = Path(player_a).parent.name if Path(player_a).name == "main.py" else Path(player_a).stem
+    name_b = Path(player_b).parent.name if Path(player_b).name == "main.py" else Path(player_b).stem
+
+    console.print(f"[bold]Running match:[/bold] {name_a} vs {name_b}")
+    tle_label = "off" if tle == 0 else f"{tle}ms"
+    console.print(f"  Map: {mp.name}  Seed: {seed}  Replay: {replay}  TLE: {tle_label}")
+
+    try:
+        result = run_game(player_a, player_b, engine_root, resolved_map, replay, seed, tle)
+    except Exception as e:
+        console.print(f"[red bold]Error:[/red bold] {e}")
+        raise SystemExit(1)
+
+    if os.path.exists(replay):
+        console.print(f"[green]Replay written to {replay}[/green]")
+
+    _print_summary(console, result, name_a, name_b)
+
+    if auto_watch:
+        from fcode.commands import watch as watch_mod
+        ctx = click.get_current_context()
+        ctx.invoke(watch_mod.watch, replay_file=replay)
+
+    # Skip normal Py_Finalize to avoid CPython 3.12 bug where
+    # Py_EndInterpreter doesn't fully unregister sub-interpreters,
+    # causing a fatal "remaining subinterpreters" abort on exit.
+    os._exit(0)
+
+    # do not put code after this