How to automate MechaPip predictions with AI

"""MechaPip RSS quickstart: fetch the public predictions feed, print clean JSON.

Standard library only. Each prediction post embeds a schema.org JSON-LD
ItemList of SportsEvent nodes in its description; this script walks that
surface and normalizes it into plain rows.

Usage:
  python rss_quickstart.py
  python rss_quickstart.py --date 2026-10-05
  python rss_quickstart.py --write predictions.json
"""
from __future__ import annotations

import argparse
import html
import json
import re
import sys
import urllib.request
import xml.etree.ElementTree as ET
from datetime import datetime, timezone

RSS_URL = "https://www.mechapip.com/rss.xml"
USER_AGENT = "MechaPipRSSQuickstart/1.0 (+https://www.mechapip.com/)"
SCRIPT_BLOCK_RE = re.compile(
    r'<script type="application/ld\+json">(.*?)</script>', re.DOTALL
)
TITLE_DATE_RE = re.compile(r"MechaPip Predictions - (\d{4}-\d{2}-\d{2})")
EVENT_RE = re.compile(r":\s*(.+?)\s+projected\s+(\d{1,3})\s+percent")


def fetch_feed(url: str = RSS_URL, timeout: int = 30) -> str:
    """Download the feed and return it as text."""
    request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
    with urllib.request.urlopen(request, timeout=timeout) as response:
        return response.read().decode("utf-8", "replace")


def _load_block(block: str) -> object:
    """Parse one JSON-LD block, tolerating HTML entities inside string values."""
    last_error: Exception | None = None
    for candidate in (html.unescape(block), block):
        try:
            return json.loads(candidate)
        except json.JSONDecodeError as exc:
            last_error = exc
    raise last_error if last_error else ValueError("empty JSON-LD block")


def _json_ld_payloads(description_html: str):
    """Yield every JSON-LD payload found in a post description."""
    for raw in SCRIPT_BLOCK_RE.findall(description_html):
        block = raw.strip()
        if not block:
            continue
        yield _load_block(block)


def _rows_from_payload(payload: object) -> list[dict]:
    """Extract normalized prediction rows from one JSON-LD payload."""
    rows: list[dict] = []
    if not isinstance(payload, dict):
        return rows
    graph = payload.get("@graph")
    if not isinstance(graph, list):
        return rows
    for node in graph:
        if not isinstance(node, dict) or node.get("@type") != "ItemList":
            continue
        for entry in node.get("itemListElement") or []:
            event = (entry or {}).get("item") or {}
            if not isinstance(event, dict) or event.get("@type") != "SportsEvent":
                continue
            description = str(event.get("description") or "")
            match = EVENT_RE.search(description)
            rows.append(
                {
                    "sport": event.get("sport", ""),
                    "away": (event.get("awayTeam") or {}).get("name", ""),
                    "home": (event.get("homeTeam") or {}).get("name", ""),
                    "kickoff_utc": event.get("startDate", ""),
                    "projected_winner": match.group(1) if match else "",
                    "win_pct": int(match.group(2)) if match else None,
                }
            )
    return rows


def parse_feed(feed_xml: str) -> list[dict]:
    """Return one row per scheduled game across every prediction post."""
    root = ET.fromstring(feed_xml)
    rows: list[dict] = []
    for item in root.iter("item"):
        title = (item.findtext("title") or "").strip()
        title_match = TITLE_DATE_RE.search(title)
        if not title_match:
            continue
        board_date = title_match.group(1)
        link = (item.findtext("link") or "").strip()
        published = (item.findtext("pubDate") or "").strip()
        description = item.findtext("description") or ""
        for payload in _json_ld_payloads(description):
            for row in _rows_from_payload(payload):
                row["board_date"] = board_date
                row["post_url"] = link
                row["published"] = published
                rows.append(row)

    deduped: dict[tuple, dict] = {}
    for row in rows:
        key = (row["board_date"], row["sport"], row["away"], row["home"])
        deduped.setdefault(key, row)
    return sorted(
        deduped.values(),
        key=lambda row: (row["board_date"], row["kickoff_utc"] or "", row["sport"]),
    )


def build_payload(rows: list[dict], source: str = RSS_URL) -> dict:
    """Wrap rows in the envelope written to stdout / disk."""
    return {
        "source": source,
        "fetched_at": datetime.now(timezone.utc).isoformat(),
        "count": len(rows),
        "predictions": rows,
    }


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(
        description="Fetch the MechaPip RSS feed and print normalized JSON."
    )
    parser.add_argument("--url", default=RSS_URL, help="feed URL")
    parser.add_argument("--date", default="", help="keep one board date, e.g. 2026-10-05")
    parser.add_argument("--write", default="", help="write JSON to this path instead of stdout")
    args = parser.parse_args(argv)

    rows = parse_feed(fetch_feed(args.url))
    if args.date:
        rows = [row for row in rows if row["board_date"] == args.date]
    output = json.dumps(build_payload(rows, args.url), indent=2)
    if args.write:
        with open(args.write, "w", encoding="utf-8") as handle:
            handle.write(output + "\n")
        print("wrote %s (%d predictions)" % (args.write, len(rows)))
    else:
        print(output)
    return 0


if __name__ == "__main__":
    sys.exit(main())