espn-odds-scraper 0.2.0__py3-none-any.whl

espn_odds_scraper/__init__.py

@@ -0,0 +1,35 @@
+"""ESPN MLB odds scraper package."""
+
+from .scraper import (
+    scrape_espn_mlb,
+    scrape_espn_mlb_years,
+    get_games,
+    get_odds,
+    fetch_line_history,
+    get_open_close,
+    to_legacy_format,
+    clean_game_data,
+)
+from .pipeline import (
+    scrape,
+    scrape_line_movement,
+    add_game_ids,
+    get_mlb_team_map,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "scrape",
+    "scrape_line_movement",
+    "add_game_ids",
+    "get_mlb_team_map",
+    "scrape_espn_mlb",
+    "scrape_espn_mlb_years",
+    "get_games",
+    "get_odds",
+    "fetch_line_history",
+    "get_open_close",
+    "to_legacy_format",
+    "clean_game_data",
+]

espn_odds_scraper/pipeline.py

@@ -0,0 +1,453 @@
+"""STATSAPI V2 pipeline integration: sbr_odds-style output with MLB game_ids.
+
+Usage in Main.ipynb:
+
+    import espn_odds_scraper as espn
+
+    if update_espn_odds:
+        espn_odds = espn.scrape(fetch_start_date, fetch_end_date, engine)
+        pdu.to_sql_upsert(espn_odds, 'espn_odds', engine,
+                          ['game_id', 'sportsbook', 'odds_type'])
+
+    # one-time historical movement backfill (ESPN carries this <=2023 only):
+    # movement = espn.scrape_line_movement('2015-04-01', '2023-11-01', engine)
+    # pdu.to_sql_upsert(movement, 'espn_line_movement', engine,
+    #                   ['espn_game_id', 'market', 'timestamp'])
+"""
+
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Iterable
+
+import pandas as pd
+import requests
+
+from .scraper import (
+    CORE_BASE,
+    BET_TYPES,
+    HISTORY_PROVIDER_ID,
+    SCOREBOARD_URL,
+    _daterange,
+    _date_str,
+    _get_json,
+    _pick,
+    _to_num,
+)
+
+TEAM_NAME_ALIASES = {
+    "d-backs": "diamondbacks",
+    "diamondbacks": "diamondbacks",
+    "athletics": "athletics",
+    "a's": "athletics",
+    "oakland athletics": "athletics",
+}
+
+
+# ---------------------------------------------------------------------------
+# Schedule (includes venue) and per-book odds with open/current snapshots
+# ---------------------------------------------------------------------------
+
+def _get_games_pipeline(date):
+    data = _get_json(SCOREBOARD_URL, params={"dates": _date_str(date)})
+    if not data:
+        return []
+    games = []
+    for event in data.get("events", []):
+        try:
+            comp = event["competitions"][0]
+            status = comp.get("status", {}).get("type", {})
+            row = {
+                "espn_game_id": event["id"],
+                "game_datetime": event.get("date"),
+                "status": status.get("name", ""),
+                "completed": bool(status.get("completed", False)),
+                "venue": _pick(comp, "venue", "fullName") or "",
+            }
+            for side in comp.get("competitors", []):
+                prefix = "home" if side.get("homeAway") == "home" else "away"
+                team = side.get("team", {})
+                row[f"{prefix}_team"] = team.get("displayName", "")
+                row[f"{prefix}_team_short"] = team.get("abbreviation", "")
+                score = side.get("score", "")
+                row[f"{prefix}_score"] = (
+                    pd.to_numeric(score, errors="coerce") if score != "" else None
+                )
+            games.append(row)
+        except Exception as e:  # noqa: BLE001
+            print(f"Error parsing ESPN event on {date}: {e}")
+    return games
+
+
+def _parse_phase_flat(item, phase):
+    home = _pick(item, "homeTeamOdds", phase) or {}
+    away = _pick(item, "awayTeamOdds", phase) or {}
+    totals = item.get(phase) or {}
+    return {
+        "home_ml": _to_num(_pick(home, "moneyLine", "american")),
+        "away_ml": _to_num(_pick(away, "moneyLine", "american")),
+        "spread": _to_num(_pick(home, "pointSpread", "american")),
+        "home_spread_odds": _to_num(_pick(home, "spread", "american")),
+        "away_spread_odds": _to_num(_pick(away, "spread", "american")),
+        "total": _to_num(_pick(totals, "total", "american")),
+        "over_odds": _to_num(_pick(totals, "over", "american")),
+        "under_odds": _to_num(_pick(totals, "under", "american")),
+    }
+
+
+def _get_odds_pipeline(espn_game_id):
+    url = f"{CORE_BASE}/events/{espn_game_id}/competitions/{espn_game_id}/odds"
+    data = _get_json(url)
+    if not data:
+        return []
+    rows = []
+    for item in data.get("items", []):
+        try:
+            provider = item.get("provider", {})
+            cur = _parse_phase_flat(item, "current")
+            opn = _parse_phase_flat(item, "open")
+            if cur["home_ml"] is None:
+                cur["home_ml"] = _to_num(_pick(item, "homeTeamOdds", "moneyLine"))
+            if cur["away_ml"] is None:
+                cur["away_ml"] = _to_num(_pick(item, "awayTeamOdds", "moneyLine"))
+            if cur["total"] is None:
+                cur["total"] = _to_num(item.get("overUnder"))
+            if cur["over_odds"] is None:
+                cur["over_odds"] = _to_num(item.get("overOdds"))
+            if cur["under_odds"] is None:
+                cur["under_odds"] = _to_num(item.get("underOdds"))
+            rows.append(
+                {
+                    "espn_game_id": str(espn_game_id),
+                    "sportsbook": provider.get("name", ""),
+                    "sportsbook_id": provider.get("id", ""),
+                    "current": cur,
+                    "open": opn,
+                }
+            )
+        except Exception as e:  # noqa: BLE001
+            print(f"Error parsing odds for ESPN game {espn_game_id}: {e}")
+    return rows
+
+
+# ---------------------------------------------------------------------------
+# MLB game_id mapping (same approach as picktheodds_scraper.add_game_ids)
+# ---------------------------------------------------------------------------
+
+def _normalize_team_name(name: str) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", " ", str(name).lower()).strip()
+    normalized = re.sub(r"\s+", " ", normalized)
+    return TEAM_NAME_ALIASES.get(normalized, normalized)
+
+
+def get_mlb_team_map() -> pd.DataFrame:
+    response = requests.get(
+        "https://statsapi.mlb.com/api/v1/teams?sportId=1", timeout=30
+    )
+    response.raise_for_status()
+    rows = []
+    for team in response.json().get("teams", []):
+        team_id = team.get("id")
+        names = {
+            team.get("name"),
+            team.get("teamName"),
+            team.get("clubName"),
+            team.get("shortName"),
+            team.get("abbreviation"),
+        }
+        for name in names:
+            if name:
+                rows.append(
+                    {"team_name_key": _normalize_team_name(name),
+                     "mlb_team_id": team_id}
+                )
+    return pd.DataFrame(rows).drop_duplicates("team_name_key")
+
+
+def add_game_ids(
+    espn_games: pd.DataFrame,
+    engine,
+    schedule_table: str = "cleaned_schedule",
+    tz: str = "US/Eastern",
+    tolerance_hrs: int = 12,
+) -> pd.DataFrame:
+    """Attach MLB statsapi game_id to ESPN games via the schedule table."""
+    if espn_games.empty or engine is None:
+        espn_games = espn_games.copy()
+        espn_games["game_id"] = None
+        return espn_games
+
+    try:
+        schedule = pd.read_sql_table(schedule_table, engine)
+    except ValueError:
+        schedule = pd.read_sql_table("processed_schedule", engine)
+
+    team_map = get_mlb_team_map()
+    espn_games = espn_games.copy()
+    espn_games["home_team_key"] = espn_games["home_team"].apply(_normalize_team_name)
+    espn_games["away_team_key"] = espn_games["away_team"].apply(_normalize_team_name)
+
+    espn_games = espn_games.merge(
+        team_map.rename(columns={"team_name_key": "home_team_key",
+                                 "mlb_team_id": "home_mlb_team_id"}),
+        on="home_team_key", how="left",
+    )
+    espn_games = espn_games.merge(
+        team_map.rename(columns={"team_name_key": "away_team_key",
+                                 "mlb_team_id": "away_mlb_team_id"}),
+        on="away_team_key", how="left",
+    )
+
+    schedule = schedule[
+        ["game_id", "game_datetime", "home_team", "away_team"]
+    ].copy()
+    schedule.rename(
+        columns={"home_team": "home_mlb_team_id", "away_team": "away_mlb_team_id"},
+        inplace=True,
+    )
+    schedule["merge_datetime"] = (
+        pd.to_datetime(schedule["game_datetime"], utc=True)
+        .dt.tz_convert(tz)
+        .dt.tz_localize(None)
+        .astype("datetime64[us]")
+    )
+    schedule = schedule.drop(columns=["game_datetime"]).sort_values("merge_datetime")
+
+    espn_games["merge_datetime"] = (
+        pd.to_datetime(espn_games["game_datetime"], utc=True)
+        .dt.tz_convert(tz)
+        .dt.tz_localize(None)
+        .astype("datetime64[us]")
+    )
+    espn_games.sort_values("merge_datetime", inplace=True)
+
+    espn_games = pd.merge_asof(
+        espn_games,
+        schedule,
+        on="merge_datetime",
+        by=["home_mlb_team_id", "away_mlb_team_id"],
+        direction="nearest",
+        tolerance=pd.Timedelta(f"{tolerance_hrs}hr"),
+    )
+    espn_games.drop(columns=["home_team_key", "away_team_key", "merge_datetime"],
+                    inplace=True)
+    espn_games["_has_game_id"] = espn_games["game_id"].notna()
+    espn_games.sort_values(["espn_game_id", "_has_game_id"],
+                           ascending=[True, False], inplace=True)
+    espn_games.drop_duplicates("espn_game_id", keep="first", inplace=True)
+    espn_games.drop(columns=["_has_game_id"], inplace=True)
+
+    mapped = espn_games["game_id"].notna().sum()
+    if mapped < len(espn_games):
+        missing = espn_games.loc[espn_games["game_id"].isna(), "game_datetime"]
+        missing_dates = sorted(pd.to_datetime(missing).dt.date.unique())
+        print(
+            f"Mapped {mapped}/{len(espn_games)} ESPN games to MLB game_id. "
+            f"Missing dates in {schedule_table}: {missing_dates[:5]}"
+        )
+    return espn_games
+
+
+# ---------------------------------------------------------------------------
+# Main entry point (sbr_odds-style long output)
+# ---------------------------------------------------------------------------
+
+ESPN_ODDS_COLUMNS = [
+    "game_id", "espn_game_id", "date", "game_datetime",
+    "away_team", "away_team_short", "home_team", "home_team_short",
+    "away_score", "home_score", "venue", "status",
+    "sportsbook", "sportsbook_id", "odds_type",
+    "opening_home_odds", "opening_away_odds", "opening_line",
+    "current_home_odds", "current_away_odds", "current_line",
+    "scraped_at",
+]
+
+
+def scrape(
+    start_date: str,
+    end_date: str,
+    engine=None,
+    odds_types: Iterable[str] = ("moneyline", "spread", "total"),
+    exclude_live: bool = True,
+    max_workers: int = 8,
+    schedule_table: str = "cleaned_schedule",
+) -> pd.DataFrame:
+    """Scrape ESPN MLB odds shaped like the sbr_odds table.
+
+    One row per game x sportsbook x odds_type. For totals, home = over and
+    away = under. 'current' odds are the closing line for completed games.
+    Opening odds are real from ~2024 onward; for <=2023 openers use
+    scrape_line_movement.
+
+    Upsert with keys ['game_id', 'sportsbook', 'odds_type'].
+    """
+    dates = _daterange(start_date, end_date)
+
+    games = []
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for result in pool.map(_get_games_pipeline, dates):
+            games.extend(result)
+    print(f"Found {len(games)} ESPN games between {start_date} and {end_date}")
+    if not games:
+        return pd.DataFrame(columns=ESPN_ODDS_COLUMNS)
+
+    games_df = pd.DataFrame(games)
+    games_df = add_game_ids(games_df, engine, schedule_table=schedule_table)
+
+    odds_rows = []
+    ids = games_df["espn_game_id"].tolist()
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(_get_odds_pipeline, gid): gid for gid in ids}
+        for future in as_completed(futures):
+            odds_rows.extend(future.result())
+    print(f"Fetched odds for {len(ids)} games: {len(odds_rows)} book entries")
+
+    if exclude_live:
+        odds_rows = [
+            r for r in odds_rows if "live odds" not in r["sportsbook"].lower()
+        ]
+
+    games_idx = games_df.set_index("espn_game_id")
+    scraped_at = int(time.time())
+    rows = []
+    for entry in odds_rows:
+        gid = entry["espn_game_id"]
+        if gid not in games_idx.index:
+            continue
+        game = games_idx.loc[gid]
+        base = {
+            "game_id": game["game_id"],
+            "espn_game_id": gid,
+            "date": pd.to_datetime(game["game_datetime"], utc=True)
+            .tz_convert("US/Eastern").strftime("%Y-%m-%d"),
+            "game_datetime": game["game_datetime"],
+            "away_team": game["away_team"],
+            "away_team_short": game["away_team_short"],
+            "home_team": game["home_team"],
+            "home_team_short": game["home_team_short"],
+            "away_score": game["away_score"],
+            "home_score": game["home_score"],
+            "venue": game["venue"],
+            "status": game["status"],
+            "sportsbook": entry["sportsbook"],
+            "sportsbook_id": entry["sportsbook_id"],
+            "scraped_at": scraped_at,
+        }
+        cur, opn = entry["current"], entry["open"]
+        market_fields = {
+            "moneyline": {
+                "opening_home_odds": opn["home_ml"],
+                "opening_away_odds": opn["away_ml"],
+                "opening_line": None,
+                "current_home_odds": cur["home_ml"],
+                "current_away_odds": cur["away_ml"],
+                "current_line": None,
+            },
+            "spread": {
+                "opening_home_odds": opn["home_spread_odds"],
+                "opening_away_odds": opn["away_spread_odds"],
+                "opening_line": opn["spread"],
+                "current_home_odds": cur["home_spread_odds"],
+                "current_away_odds": cur["away_spread_odds"],
+                "current_line": cur["spread"],
+            },
+            # totals: home = over, away = under
+            "total": {
+                "opening_home_odds": opn["over_odds"],
+                "opening_away_odds": opn["under_odds"],
+                "opening_line": opn["total"],
+                "current_home_odds": cur["over_odds"],
+                "current_away_odds": cur["under_odds"],
+                "current_line": cur["total"],
+            },
+        }
+        for odds_type in odds_types:
+            fields = market_fields.get(odds_type)
+            if fields is None:
+                print(f"Unknown odds_type '{odds_type}', skipping")
+                continue
+            if all(v is None for v in fields.values()):
+                continue
+            rows.append({**base, "odds_type": odds_type, **fields})
+
+    result = pd.DataFrame(rows, columns=ESPN_ODDS_COLUMNS)
+    print(f"Built {len(result)} espn_odds rows.")
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Line movement for the pipeline (<=2023 only)
+# ---------------------------------------------------------------------------
+
+def _fetch_history_pipeline(espn_game_id, mlb_game_id=None,
+                            markets=("moneyline", "spread", "total")):
+    rows = []
+    for market in markets:
+        bet_type = BET_TYPES.get(market)
+        if bet_type is None:
+            continue
+        url = (
+            f"{CORE_BASE}/events/{espn_game_id}/competitions/{espn_game_id}"
+            f"/odds/{HISTORY_PROVIDER_ID}/history/{bet_type}/movement"
+        )
+        data = _get_json(url, params={"limit": 1000})
+        if not data:
+            continue
+        for item in data.get("items", []):
+            rows.append(
+                {
+                    "game_id": mlb_game_id,
+                    "espn_game_id": str(espn_game_id),
+                    "market": market,
+                    "timestamp": item.get("lineDate"),
+                    "away_odds": _to_num(item.get("awayOdds")),
+                    "home_odds": _to_num(item.get("homeOdds")),
+                    "over_odds": _to_num(item.get("overOdds")),
+                    "under_odds": _to_num(item.get("underOdds")),
+                    "line": item.get("line"),
+                }
+            )
+    df = pd.DataFrame(rows)
+    if not df.empty:
+        df = df.sort_values(["market", "timestamp"]).reset_index(drop=True)
+    return df
+
+
+def scrape_line_movement(
+    start_date: str,
+    end_date: str,
+    engine=None,
+    max_workers: int = 8,
+    schedule_table: str = "cleaned_schedule",
+) -> pd.DataFrame:
+    """Timestamped line movement for every game in the range (<=2023 only).
+
+    Upsert with keys ['espn_game_id', 'market', 'timestamp'].
+    """
+    dates = _daterange(start_date, end_date)
+    games = []
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for result in pool.map(_get_games_pipeline, dates):
+            games.extend(result)
+    if not games:
+        return pd.DataFrame()
+    games_df = add_game_ids(pd.DataFrame(games), engine,
+                            schedule_table=schedule_table)
+
+    frames = []
+    pairs = list(zip(games_df["espn_game_id"], games_df["game_id"]))
+    print(f"Fetching line movement for {len(pairs)} games...")
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {
+            pool.submit(_fetch_history_pipeline, egid, gid): egid
+            for egid, gid in pairs
+        }
+        for future in as_completed(futures):
+            df = future.result()
+            if not df.empty:
+                frames.append(df)
+    movement = (
+        pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+    )
+    print(f"Fetched {len(movement)} line-movement rows.")
+    return movement

espn_odds_scraper/scraper.py

@@ -0,0 +1,664 @@
+"""ESPN MLB odds scraper.
+
+Pulls MLB odds (moneyline, run line, total) for every sportsbook ESPN carries,
+plus timestamped line-movement history, from ESPN's public (undocumented) APIs.
+
+Endpoints used
+--------------
+Scoreboard (schedule + scores, 1 request per day):
+    https://site.api.espn.com/apis/site/v2/sports/baseball/mlb/scoreboard?dates=YYYYMMDD
+
+Odds (all books for one game, 1 request per game):
+    https://sports.core.api.espn.com/v2/sports/baseball/leagues/mlb/
+        events/{id}/competitions/{id}/odds
+
+Line movement (timestamped, consensus feed, 1 request per market per game):
+    .../odds/{provider_id}/history/{bet_type}/movement
+
+Notes
+-----
+- Game datetimes are exact UTC timestamps.
+- For completed games the per-book "current" block is frozen at game time,
+  i.e. it is effectively the closing line.
+- Full ML/spread/total coverage is solid from ~2015 onward. Older seasons
+  exist but are degraded (moneylines often 0).
+"""
+
+import datetime
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import pandas as pd
+import requests
+
+SCOREBOARD_URL = (
+    "https://site.api.espn.com/apis/site/v2/sports/baseball/mlb/scoreboard"
+)
+CORE_BASE = "https://sports.core.api.espn.com/v2/sports/baseball/leagues/mlb"
+
+# Provider that carries timestamped line-movement history
+HISTORY_PROVIDER_ID = "1002"  # "teamrankings" (ESPN's consensus movement feed)
+
+# bet_type ids for the history endpoint
+BET_TYPES = {"moneyline": 0, "spread": 1, "total": 2}
+
+_thread_local = threading.local()
+
+_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+    ),
+    "Accept": "application/json",
+}
+
+
+def _session() -> requests.Session:
+    """One requests.Session per thread (sessions are not thread-safe)."""
+    if not hasattr(_thread_local, "session"):
+        s = requests.Session()
+        s.headers.update(_HEADERS)
+        _thread_local.session = s
+    return _thread_local.session
+
+
+def _get_json(url, params=None, retries=3, timeout=15):
+    last_err = None
+    for attempt in range(retries):
+        try:
+            resp = _session().get(url, params=params, timeout=timeout)
+            if resp.status_code == 200:
+                return resp.json()
+            last_err = f"HTTP {resp.status_code}"
+        except Exception as e:  # noqa: BLE001
+            last_err = e
+        time.sleep(1.5 * (attempt + 1))
+    print(f"Failed GET {url}: {last_err}")
+    return None
+
+
+def _to_num(value):
+    """Parse ESPN american-odds strings like '+165', '-110', 'EVEN'."""
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return value if value != 0 else None
+    s = str(value).strip().replace("+", "")
+    if s.upper() in ("EVEN", "EV"):
+        return 100.0
+    try:
+        num = float(s)
+    except ValueError:
+        return None
+    # 0 is never a real price/line on ESPN; it means "missing"
+    return num if num != 0 else None
+
+
+def _date_str(d) -> str:
+    """Normalize date-ish input to YYYYMMDD."""
+    if isinstance(d, str):
+        d = pd.to_datetime(d)
+    if isinstance(d, (datetime.datetime, pd.Timestamp)):
+        d = d.date()
+    return d.strftime("%Y%m%d")
+
+
+def _daterange(start_date, end_date):
+    start = pd.to_datetime(start_date).date()
+    end = pd.to_datetime(end_date).date()
+    days = (end - start).days
+    return [start + datetime.timedelta(days=i) for i in range(days + 1)]
+
+
+# ---------------------------------------------------------------------------
+# Schedule / scores
+# ---------------------------------------------------------------------------
+
+def get_games(date):
+    """Return the list of MLB games for one date (schedule, teams, scores).
+
+    Args:
+        date: date/datetime/'YYYY-MM-DD'
+
+    Returns:
+        list[dict]: one dict per game with keys:
+            game_id, game_datetime (UTC ISO string), status, completed,
+            home_team_abbr, home_team_name, home_team_espn_id, home_score,
+            away_team_abbr, away_team_name, away_team_espn_id, away_score
+    """
+    data = _get_json(SCOREBOARD_URL, params={"dates": _date_str(date)})
+    if not data:
+        return []
+
+    games = []
+    for event in data.get("events", []):
+        try:
+            comp = event["competitions"][0]
+            status = comp.get("status", {}).get("type", {})
+            row = {
+                "game_id": event["id"],
+                "game_datetime": event.get("date"),
+                "status": status.get("name", ""),
+                "completed": bool(status.get("completed", False)),
+            }
+            for side in comp.get("competitors", []):
+                prefix = "home" if side.get("homeAway") == "home" else "away"
+                team = side.get("team", {})
+                row[f"{prefix}_team_abbr"] = team.get("abbreviation", "")
+                row[f"{prefix}_team_name"] = team.get("displayName", "")
+                row[f"{prefix}_team_espn_id"] = team.get("id", "")
+                score = side.get("score", "")
+                row[f"{prefix}_score"] = (
+                    pd.to_numeric(score, errors="coerce") if score != "" else None
+                )
+            games.append(row)
+        except Exception as e:  # noqa: BLE001
+            print(f"Error parsing event on {date}: {e}")
+    return games
+
+
+# ---------------------------------------------------------------------------
+# Odds
+# ---------------------------------------------------------------------------
+
+def _pick(d, *keys):
+    """Nested dict get: _pick(x, 'a', 'b') -> x['a']['b'] or None."""
+    for k in keys:
+        if not isinstance(d, dict):
+            return None
+        d = d.get(k)
+    return d
+
+
+def _parse_side(side_odds):
+    """Parse home/awayTeamOdds block -> (moneyline, spread_line, spread_odds)."""
+    if not isinstance(side_odds, dict):
+        return None, None, None
+    ml = _to_num(side_odds.get("moneyLine"))
+    # Prefer the "current" block (frozen at game time = closing for past games)
+    cur = side_odds.get("current") or {}
+    ml_cur = _to_num(_pick(cur, "moneyLine", "american"))
+    if ml_cur is not None:
+        ml = ml_cur
+    spread_line = _to_num(_pick(cur, "pointSpread", "american"))
+    spread_odds = _to_num(_pick(cur, "spread", "american"))
+    if spread_odds is None:
+        spread_odds = _to_num(side_odds.get("spreadOdds"))
+    return ml, spread_line, spread_odds
+
+
+def _parse_phase(item, phase):
+    """Extract one snapshot ('open' or 'close') from an odds item.
+
+    ESPN attaches real open/close blocks per book from ~2024 onward
+    (ESPN BET / DraftKings era). Older seasons carry junk here ("+0"),
+    which _to_num maps to None.
+
+    Returns a dict of {phase}_home_ml, {phase}_away_ml, {phase}_spread,
+    {phase}_home_spread_odds, {phase}_away_spread_odds, {phase}_total,
+    {phase}_over_odds, {phase}_under_odds.
+    """
+    home = _pick(item, "homeTeamOdds", phase) or {}
+    away = _pick(item, "awayTeamOdds", phase) or {}
+    totals = item.get(phase) or {}
+    return {
+        f"{phase}_home_ml": _to_num(_pick(home, "moneyLine", "american")),
+        f"{phase}_away_ml": _to_num(_pick(away, "moneyLine", "american")),
+        f"{phase}_spread": _to_num(_pick(home, "pointSpread", "american")),
+        f"{phase}_home_spread_odds": _to_num(_pick(home, "spread", "american")),
+        f"{phase}_away_spread_odds": _to_num(_pick(away, "spread", "american")),
+        f"{phase}_total": _to_num(_pick(totals, "total", "american")),
+        f"{phase}_over_odds": _to_num(_pick(totals, "over", "american")),
+        f"{phase}_under_odds": _to_num(_pick(totals, "under", "american")),
+    }
+
+
+def get_odds(game_id):
+    """Return odds rows (one per sportsbook) for a single game.
+
+    Args:
+        game_id: ESPN event id (str or int)
+
+    Returns:
+        list[dict]: keys: game_id, provider_id, provider,
+            home_ml, away_ml, spread, home_spread_odds, away_spread_odds,
+            total, over_odds, under_odds, moneyline_winner, spread_winner
+    """
+    url = f"{CORE_BASE}/events/{game_id}/competitions/{game_id}/odds"
+    data = _get_json(url)
+    if not data:
+        return []
+
+    rows = []
+    for item in data.get("items", []):
+        try:
+            provider = item.get("provider", {})
+            home = item.get("homeTeamOdds", {})
+            away = item.get("awayTeamOdds", {})
+
+            home_ml, home_spread_line, home_spread_odds = _parse_side(home)
+            away_ml, _away_spread_line, away_spread_odds = _parse_side(away)
+
+            # Spread relative to the home team
+            spread = home_spread_line
+            if spread is None:
+                raw = _to_num(item.get("spread"))
+                if raw is not None and abs(raw) <= 30:
+                    # item['spread'] is the favorite's line magnitude
+                    spread = -raw if home.get("favorite") else raw
+
+            total = _to_num(item.get("overUnder"))
+            over_odds = _to_num(item.get("overOdds"))
+            under_odds = _to_num(item.get("underOdds"))
+            cur = item.get("current") or {}
+            over_cur = _to_num(_pick(cur, "over", "american"))
+            under_cur = _to_num(_pick(cur, "under", "american"))
+            total_cur = _to_num(_pick(cur, "total", "american"))
+            if over_cur is not None:
+                over_odds = over_cur
+            if under_cur is not None:
+                under_odds = under_cur
+            if total_cur is not None:
+                total = total_cur
+
+            row = {
+                "game_id": str(game_id),
+                "provider_id": provider.get("id", ""),
+                "provider": provider.get("name", ""),
+                "home_ml": home_ml,
+                "away_ml": away_ml,
+                "spread": spread,
+                "home_spread_odds": home_spread_odds,
+                "away_spread_odds": away_spread_odds,
+                "total": total,
+                "over_odds": over_odds,
+                "under_odds": under_odds,
+                "moneyline_winner": item.get("moneylineWinner"),
+                "spread_winner": item.get("spreadWinner"),
+            }
+            # Per-book open/close snapshots (real data from ~2024 onward)
+            row.update(_parse_phase(item, "open"))
+            row.update(_parse_phase(item, "close"))
+            rows.append(row)
+        except Exception as e:  # noqa: BLE001
+            print(f"Error parsing odds for game {game_id}: {e}")
+    return rows
+
+
+# ---------------------------------------------------------------------------
+# Line movement (timestamped history)
+# ---------------------------------------------------------------------------
+
+def fetch_line_history(game_id, markets=("moneyline", "spread", "total"),
+                       provider_id=HISTORY_PROVIDER_ID):
+    """Fetch full timestamped line movement for one game.
+
+    ESPN keeps movement history on its consensus feed (provider 1002,
+    "teamrankings"). One request per market.
+
+    NOTE: ESPN dropped this feed after the 2023 season. For 2024+ use the
+    per-book open_*/close_* columns returned by scrape_espn_mlb instead.
+
+    Args:
+        game_id: ESPN event id
+        markets: iterable of 'moneyline' / 'spread' / 'total'
+        provider_id: odds provider id carrying history (default consensus)
+
+    Returns:
+        pd.DataFrame: columns game_id, market, line_date (UTC),
+            away_odds, home_odds, over_odds, under_odds, line.
+            Sorted by line_date; the first row per market is the opener,
+            the last is the closer. Empty DataFrame if no history exists.
+    """
+    rows = []
+    for market in markets:
+        bet_type = BET_TYPES.get(market)
+        if bet_type is None:
+            print(f"Unknown market '{market}', skipping")
+            continue
+        url = (
+            f"{CORE_BASE}/events/{game_id}/competitions/{game_id}"
+            f"/odds/{provider_id}/history/{bet_type}/movement"
+        )
+        data = _get_json(url, params={"limit": 1000})
+        if not data:
+            continue
+        for item in data.get("items", []):
+            rows.append(
+                {
+                    "game_id": str(game_id),
+                    "market": market,
+                    "line_date": item.get("lineDate"),
+                    "away_odds": _to_num(item.get("awayOdds")),
+                    "home_odds": _to_num(item.get("homeOdds")),
+                    "over_odds": _to_num(item.get("overOdds")),
+                    "under_odds": _to_num(item.get("underOdds")),
+                    "line": item.get("line"),
+                }
+            )
+    df = pd.DataFrame(rows)
+    if not df.empty:
+        df["line_date"] = pd.to_datetime(df["line_date"], utc=True)
+        df = df.sort_values(["market", "line_date"]).reset_index(drop=True)
+    return df
+
+
+def get_open_close(movement_df):
+    """Collapse a movement DataFrame to opening/closing lines.
+
+    Args:
+        movement_df: output of fetch_line_history / scrape_espn_mlb(...)[1]
+
+    Returns:
+        pd.DataFrame: one row per game_id x market with
+            open_date, open_away_odds, open_home_odds, open_over_odds,
+            open_under_odds, open_line, close_date, close_* equivalents.
+    """
+    if movement_df is None or movement_df.empty:
+        return pd.DataFrame()
+
+    df = movement_df.sort_values("line_date")
+    grouped = df.groupby(["game_id", "market"], as_index=False)
+    first = grouped.first().rename(
+        columns={
+            "line_date": "open_date",
+            "away_odds": "open_away_odds",
+            "home_odds": "open_home_odds",
+            "over_odds": "open_over_odds",
+            "under_odds": "open_under_odds",
+            "line": "open_line",
+        }
+    )
+    last = grouped.last().rename(
+        columns={
+            "line_date": "close_date",
+            "away_odds": "close_away_odds",
+            "home_odds": "close_home_odds",
+            "over_odds": "close_over_odds",
+            "under_odds": "close_under_odds",
+            "line": "close_line",
+        }
+    )
+    return first.merge(last, on=["game_id", "market"])
+
+
+# ---------------------------------------------------------------------------
+# Main scrape entry points
+# ---------------------------------------------------------------------------
+
+def scrape_espn_mlb(start_date, end_date=None, providers=None,
+                    include_history=False, exclude_live=True, max_workers=8):
+    """Scrape MLB odds for a date range from ESPN.
+
+    Args:
+        start_date: first date (inclusive), date/'YYYY-MM-DD'
+        end_date: last date (inclusive); defaults to start_date
+        providers: optional list of provider names to keep
+            (e.g. ['DraftKings', 'FanDuel', 'consensus']); case-insensitive
+            substring match. None keeps every book.
+        include_history: if True, also fetch timestamped line movement
+            (consensus feed, ~3 extra requests per game)
+        exclude_live: drop in-game "Live Odds" feeds (default True), since
+            live lines pollute closing-line analysis
+        max_workers: concurrent request threads
+
+    Returns:
+        if include_history is False:
+            pd.DataFrame odds (one row per game x sportsbook)
+        else:
+            (odds_df, movement_df) tuple
+    """
+    if end_date is None:
+        end_date = start_date
+    dates = _daterange(start_date, end_date)
+
+    # 1) schedule + scores, one request per day (parallel)
+    games = []
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for result in pool.map(get_games, dates):
+            games.extend(result)
+    print(f"Found {len(games)} games between {start_date} and {end_date}")
+    if not games:
+        empty = pd.DataFrame()
+        return (empty, empty.copy()) if include_history else empty
+
+    games_df = pd.DataFrame(games)
+    games_df["game_datetime"] = pd.to_datetime(games_df["game_datetime"], utc=True)
+
+    # 2) odds, one request per game (parallel)
+    odds_rows = []
+    game_ids = games_df["game_id"].tolist()
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(get_odds, gid): gid for gid in game_ids}
+        for future in as_completed(futures):
+            odds_rows.extend(future.result())
+    odds_df = pd.DataFrame(odds_rows)
+    print(f"Collected {len(odds_df)} odds rows")
+
+    if odds_df.empty:
+        merged = games_df.copy()
+    else:
+        if exclude_live:
+            odds_df = odds_df[
+                ~odds_df["provider"].str.lower().str.contains("live odds", na=False)
+            ]
+        if providers:
+            wanted = [p.lower() for p in providers]
+            mask = odds_df["provider"].str.lower().apply(
+                lambda name: any(w in name for w in wanted)
+            )
+            odds_df = odds_df[mask]
+        merged = games_df.merge(odds_df, on="game_id", how="left")
+
+    col_order = [
+        "game_id", "game_datetime", "status", "completed",
+        "home_team_abbr", "away_team_abbr",
+        "home_team_name", "away_team_name",
+        "home_team_espn_id", "away_team_espn_id",
+        "home_score", "away_score",
+        "provider_id", "provider",
+        "home_ml", "away_ml",
+        "spread", "home_spread_odds", "away_spread_odds",
+        "total", "over_odds", "under_odds",
+        "open_home_ml", "open_away_ml", "open_spread",
+        "open_home_spread_odds", "open_away_spread_odds",
+        "open_total", "open_over_odds", "open_under_odds",
+        "close_home_ml", "close_away_ml", "close_spread",
+        "close_home_spread_odds", "close_away_spread_odds",
+        "close_total", "close_over_odds", "close_under_odds",
+        "moneyline_winner", "spread_winner",
+    ]
+    merged = merged[[c for c in col_order if c in merged.columns]]
+    merged = merged.sort_values(["game_datetime", "game_id"]).reset_index(drop=True)
+
+    if not include_history:
+        return merged
+
+    # 3) optional line movement (parallel, 3 requests per game)
+    movement_frames = []
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(fetch_line_history, gid): gid for gid in game_ids}
+        for future in as_completed(futures):
+            df = future.result()
+            if not df.empty:
+                movement_frames.append(df)
+    movement_df = (
+        pd.concat(movement_frames, ignore_index=True)
+        if movement_frames else pd.DataFrame()
+    )
+    print(f"Collected {len(movement_df)} line-movement rows")
+    return merged, movement_df
+
+
+def scrape_espn_mlb_years(start_year=2015, end_year=None, providers=None,
+                          include_history=False, exclude_live=True,
+                          max_workers=8):
+    """Scrape MLB odds season by season (Mar 1 through Nov 30 of each year).
+
+    Args:
+        start_year: first season (inclusive)
+        end_year: last season (exclusive, mirroring the old package);
+            defaults to current year + 1 (i.e. through the current season)
+        providers, include_history, max_workers: see scrape_espn_mlb
+
+    Returns:
+        pd.DataFrame, or (odds_df, movement_df) when include_history=True
+    """
+    if end_year is None:
+        end_year = datetime.date.today().year + 1
+    today = datetime.date.today()
+
+    odds_frames, movement_frames = [], []
+    for year in range(start_year, end_year):
+        start = datetime.date(year, 3, 1)
+        end = min(datetime.date(year, 11, 30), today)
+        if start > today:
+            break
+        print(f"\nScraping season {year} ({start} to {end})...")
+        result = scrape_espn_mlb(
+            start, end, providers=providers,
+            include_history=include_history, exclude_live=exclude_live,
+            max_workers=max_workers,
+        )
+        if include_history:
+            odds, movement = result
+            if not movement.empty:
+                movement_frames.append(movement)
+        else:
+            odds = result
+        if not odds.empty:
+            odds_frames.append(odds)
+
+    odds_df = (
+        pd.concat(odds_frames, ignore_index=True) if odds_frames else pd.DataFrame()
+    )
+    if include_history:
+        movement_df = (
+            pd.concat(movement_frames, ignore_index=True)
+            if movement_frames else pd.DataFrame()
+        )
+        return odds_df, movement_df
+    return odds_df
+
+
+# ---------------------------------------------------------------------------
+# Legacy compatibility with mlb_odds_scraper
+# ---------------------------------------------------------------------------
+
+def to_legacy_format(odds_df, provider="consensus"):
+    """Collapse the long odds DataFrame to the old mlb_odds_scraper schema.
+
+    Output columns: game_date, game_datetime, home_team, away_team (MLB
+    statsapi team ids), home_odds, away_odds (moneylines), home_score,
+    away_score, home_team_abbr, away_team_abbr.
+
+    Args:
+        odds_df: output of scrape_espn_mlb / scrape_espn_mlb_years
+        provider: which book's moneyline to use (case-insensitive substring;
+            falls back to the row with the most complete ML if not found)
+
+    Returns:
+        pd.DataFrame in the legacy schema (game_datetime tz-naive US/Eastern,
+        matching what process_game_data used to produce).
+    """
+    import statsapi
+
+    if odds_df is None or odds_df.empty:
+        return pd.DataFrame()
+
+    df = odds_df.copy()
+    df = df.dropna(subset=["home_ml", "away_ml"], how="all")
+
+    # Prefer the requested provider, else any book with a complete moneyline
+    df["_preferred"] = df["provider"].str.lower().str.contains(
+        provider.lower(), na=False
+    )
+    df["_complete"] = df["home_ml"].notna() & df["away_ml"].notna()
+    df = df.sort_values(
+        ["game_id", "_preferred", "_complete"], ascending=[True, False, False]
+    )
+    df = df.drop_duplicates("game_id", keep="first")
+
+    # Map team names to statsapi ids (like the old process_game_data)
+    names = pd.unique(
+        pd.concat([df["home_team_name"], df["away_team_name"]]).dropna()
+    )
+    mapping = {}
+    for name in names:
+        mapping[name] = None
+        # Historical names may no longer match (e.g. "Oakland Athletics"
+        # after the Athletics rename) — fall back to shorter forms.
+        candidates = [name, name.split()[-1], " ".join(name.split()[:-1])]
+        for candidate in candidates:
+            if not candidate:
+                continue
+            try:
+                info = statsapi.lookup_team(candidate)
+                if info:
+                    mapping[name] = info[0]["id"]
+                    break
+            except Exception as e:  # noqa: BLE001
+                print(f"Error looking up team {candidate}: {e}")
+        if mapping[name] is None:
+            print(f"Could not find statsapi id for team: {name}")
+
+    eastern = df["game_datetime"].dt.tz_convert("US/Eastern").dt.tz_localize(None)
+    out = pd.DataFrame(
+        {
+            "game_date": eastern.dt.normalize(),
+            "game_datetime": eastern,
+            "home_team": df["home_team_name"].map(mapping),
+            "away_team": df["away_team_name"].map(mapping),
+            "home_odds": df["home_ml"],
+            "away_odds": df["away_ml"],
+            "home_score": df["home_score"],
+            "away_score": df["away_score"],
+            "home_team_abbr": df["home_team_abbr"],
+            "away_team_abbr": df["away_team_abbr"],
+        }
+    )
+    return out.reset_index(drop=True)
+
+
+def clean_game_data(cleaned_schedule, processed_odds, tz="US/Eastern",
+                    tolerance_hrs=12):
+    """Merge a statsapi schedule with odds (same behavior as the old package)."""
+    import numpy as np
+
+    schedule = cleaned_schedule.copy()
+    odds = processed_odds.replace("", np.nan).copy()
+
+    schedule.rename(
+        columns={"home_team_score": "home_score", "away_team_score": "away_score"},
+        inplace=True,
+    )
+    schedule["game_datetime"] = (
+        pd.to_datetime(schedule["game_datetime"], utc=True)
+        .dt.tz_convert(tz)
+        .dt.tz_localize(None)
+        .astype("datetime64[us]")
+    )
+    schedule["home_score"] = schedule["home_score"].astype(int, errors="ignore")
+    schedule["away_score"] = schedule["away_score"].astype(int, errors="ignore")
+    odds["home_score"] = odds["home_score"].astype(int, errors="ignore")
+    odds["away_score"] = odds["away_score"].astype(int, errors="ignore")
+    schedule = schedule.sort_values("game_datetime")
+
+    odds["game_datetime"] = (
+        pd.to_datetime(odds["game_datetime"]).astype("datetime64[us]")
+    )
+    odds = odds.sort_values("game_datetime")
+
+    merged = pd.merge_asof(
+        schedule.drop(["game_date", "home_score", "away_score"], axis=1),
+        odds,
+        on="game_datetime",
+        by=["home_team", "away_team"],
+        direction="nearest",
+        tolerance=pd.Timedelta(f"{tolerance_hrs}hr"),
+    )
+    merged.dropna(subset=["home_odds", "away_odds"], inplace=True)
+    merged["game_datetime"] = merged["game_datetime"].dt.tz_localize(tz)
+    return merged
+

espn_odds_scraper-0.2.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: espn_odds_scraper
+Version: 0.2.0
+Summary: A package for scraping historical and live MLB odds from ESPN's public API
+Author-email: Oronto <vile319@gmail.com>
+Project-URL: Homepage, https://github.com/Oronto/espn_odds_scraper
+Project-URL: Bug Tracker, https://github.com/Oronto/espn_odds_scraper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: MLB-StatsAPI>=1.0.0
+Dynamic: license-file
+
+# espn_odds_scraper
+
+Scrape historical and live MLB odds from ESPN's public (undocumented) API. No API key, no Selenium — plain JSON requests.
+
+Successor to `mlb_odds_scraper` (OddsPortal/Selenium based). ESPN carries per-book odds (DraftKings, FanDuel, Caesars, MGM, Bet365, ...; older seasons carry BOVADA, 5Dimes, etc.), moneyline + run line + total in a single request per game, and timestamped line-movement history on its consensus feed.
+
+**Coverage:** solid from ~2015 onward. Earlier seasons exist but are degraded (moneylines often missing).
+
+## Install
+
+```bash
+pip install espn_odds_scraper
+```
+
+## Usage
+
+```python
+from espn_odds_scraper import scrape_espn_mlb, scrape_espn_mlb_years
+
+# One day, every book — one row per game x sportsbook
+df = scrape_espn_mlb("2023-07-14")
+
+# Date range, only certain books
+df = scrape_espn_mlb("2023-07-01", "2023-07-31", providers=["DraftKings", "FanDuel"])
+
+# With full timestamped line movement (opt-in, ~3 extra requests per game)
+odds, movement = scrape_espn_mlb("2023-07-14", include_history=True)
+
+# Whole seasons
+df = scrape_espn_mlb_years(2018, 2024)
+```
+
+### Odds DataFrame columns
+
+`game_id, game_datetime (UTC), status, completed, home_team_abbr, away_team_abbr, home_team_name, away_team_name, home_team_espn_id, away_team_espn_id, home_score, away_score, provider_id, provider, home_ml, away_ml, spread (home line), home_spread_odds, away_spread_odds, total, over_odds, under_odds, open_* (8 cols), close_* (8 cols), moneyline_winner, spread_winner`
+
+For completed games, per-book odds are the lines frozen at game time — effectively **closing lines**. In-game "Live Odds" feeds are dropped by default (`exclude_live=False` to keep them).
+
+### Opening / closing lines & line movement
+
+ESPN's data comes in two eras:
+
+- **2024+ (ESPN BET / DraftKings era):** each book carries real `open_*` and `close_*` snapshots (moneyline, spread + prices, total + prices) directly in the odds row — no extra requests. Fewer books, though (often just one).
+- **≤2023 (multi-book era):** `open_*`/`close_*` are empty (ESPN stored junk there), but full **timestamped line movement** exists on the consensus feed:
+
+```python
+from espn_odds_scraper import fetch_line_history, get_open_close
+
+movement = fetch_line_history("401472391")   # timestamped rows per market
+oc = get_open_close(movement)                # one row per market: open_* and close_*
+```
+
+Movement rows: `game_id, market (moneyline/spread/total), line_date (UTC), away_odds, home_odds, over_odds, under_odds, line`. First row per market is the opener, last is the closer. ESPN dropped this feed after the 2023 season.
+
+### Drop-in compatibility with mlb_odds_scraper
+
+```python
+from espn_odds_scraper import to_legacy_format, clean_game_data
+
+legacy = to_legacy_format(df)  # game_date, game_datetime, home_team/away_team
+                               # (statsapi ids), home_odds/away_odds, scores, abbrs
+merged = clean_game_data(cleaned_schedule, legacy)  # same merge helper as before
+```
+
+## Request footprint
+
+- 1 request per day (schedule + scores)
+- 1 request per game (all books, all markets)
+- optional: 3 requests per game (line movement)
+
+A full season is roughly 2,600 requests without history. Requests run through a thread pool (`max_workers=8` by default). Be polite; this is an undocumented API.
+
+## License
+
+MIT

espn_odds_scraper-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+espn_odds_scraper/__init__.py,sha256=h1ASHGNa1lf-IgZQUjw_zK74bcCBQYvN6Zr_bJrpz8g,635
+espn_odds_scraper/pipeline.py,sha256=_NXg92pDGFdh5pg1x5hZLAYUHevXNjMdIpVvrIw-qXk,16951
+espn_odds_scraper/scraper.py,sha256=bS1lGTbYzb2IR-vEobTBHaFi9g_eWnP4ia2VrEe2dWo,25016
+espn_odds_scraper-0.2.0.dist-info/licenses/LICENSE,sha256=Rf_buMTuHmw3KL4La6oAYIXdxxESqz-fXLSjtqmuaFQ,1083
+espn_odds_scraper-0.2.0.dist-info/METADATA,sha256=h92V2nW1M1BtUIB0pOD2GwkCgx2a1PWaeuIiJHgX9qU,4123
+espn_odds_scraper-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+espn_odds_scraper-0.2.0.dist-info/top_level.txt,sha256=wldnao5MmqefO_1Q-0nTPWnzZttXJ00W4k8l6HRF6mU,18
+espn_odds_scraper-0.2.0.dist-info/RECORD,,

espn_odds_scraper-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

espn_odds_scraper-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Oronto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

espn_odds_scraper-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+espn_odds_scraper