ps3838api 1.1.0__py3-none-any.whl

ps3838api/models/sports.py

@@ -0,0 +1,256 @@
+"""
+Sport identifiers exposed by the PS3838 API.
+"""
+
+from enum import IntEnum
+
+
+class Sport(IntEnum):
+    BADMINTON_SPORT_ID = 1
+    BANDY_SPORT_ID = 2
+    BASEBALL_SPORT_ID = 3
+    BASKETBALL_SPORT_ID = 4
+    BEACH_VOLLEYBALL_SPORT_ID = 5
+    BOXING_SPORT_ID = 6
+    CHESS_SPORT_ID = 7
+    CRICKET_SPORT_ID = 8
+    CURLING_SPORT_ID = 9
+    DARTS_SPORT_ID = 10
+    FIELD_HOCKEY_SPORT_ID = 13
+    FLOORBALL_SPORT_ID = 14
+    FOOTBALL_SPORT_ID = 15
+    FUTSAL_SPORT_ID = 16
+    GOLF_SPORT_ID = 17
+    HANDBALL_SPORT_ID = 18
+    HOCKEY_SPORT_ID = 19
+    HORSE_RACING_SPECIALS_SPORT_ID = 20
+    LACROSSE_SPORT_ID = 21
+    MMA_SPORT_ID = 22
+    OTHER_SPORTS_SPORT_ID = 23
+    POLITICS_SPORT_ID = 24
+    RUGBY_LEAGUE_SPORT_ID = 26
+    RUGBY_UNION_SPORT_ID = 27
+    SNOOKER_SPORT_ID = 28
+    SOCCER_SPORT_ID = 29
+    SOFTBALL_SPORT_ID = 30
+    SQUASH_SPORT_ID = 31
+    TABLE_TENNIS_SPORT_ID = 32
+    TENNIS_SPORT_ID = 33
+    VOLLEYBALL_SPORT_ID = 34
+    WATER_POLO_SPORT_ID = 36
+    PADEL_TENNIS_SPORT_ID = 37
+    AUSSIE_RULES_SPORT_ID = 39
+    ALPINE_SKIING_SPORT_ID = 40
+    BIATHLON_SPORT_ID = 41
+    SKI_JUMPING_SPORT_ID = 42
+    CROSS_COUNTRY_SPORT_ID = 43
+    FORMULA1_SPORT_ID = 44
+    CYCLING_SPORT_ID = 45
+    BOBSLEIGH_SPORT_ID = 46
+    FIGURE_SKATING_SPORT_ID = 47
+    FREESTYLE_SKIING_SPORT_ID = 48
+    LUGE_SPORT_ID = 49
+    NORDIC_COMBINED_SPORT_ID = 50
+    SHORT_TRACK_SPORT_ID = 51
+    SKELETON_SPORT_ID = 52
+    SNOWBOARDING_SPORT_ID = 53
+    SPEED_SKATING_SPORT_ID = 54
+    OLYMPICS_SPORT_ID = 55
+    ATHLETICS_SPORT_ID = 56
+    CROSSFIT_SPORT_ID = 57
+    ENTERTAINMENT_SPORT_ID = 58
+    ARCHERY_SPORT_ID = 59
+    DRONE_RACING_SPORT_ID = 60
+    POKER_SPORT_ID = 62
+    MOTORSPORT_SPORT_ID = 63
+    SIMULATED_GAMES_SPORT_ID = 64
+    SUMO_SPORT_ID = 65
+
+
+BADMINTON_SPORT_ID = Sport.BADMINTON_SPORT_ID
+BANDY_SPORT_ID = Sport.BANDY_SPORT_ID
+BASEBALL_SPORT_ID = Sport.BASEBALL_SPORT_ID
+BASKETBALL_SPORT_ID = Sport.BASKETBALL_SPORT_ID
+BEACH_VOLLEYBALL_SPORT_ID = Sport.BEACH_VOLLEYBALL_SPORT_ID
+BOXING_SPORT_ID = Sport.BOXING_SPORT_ID
+CHESS_SPORT_ID = Sport.CHESS_SPORT_ID
+CRICKET_SPORT_ID = Sport.CRICKET_SPORT_ID
+CURLING_SPORT_ID = Sport.CURLING_SPORT_ID
+DARTS_SPORT_ID = Sport.DARTS_SPORT_ID
+FIELD_HOCKEY_SPORT_ID = Sport.FIELD_HOCKEY_SPORT_ID
+FLOORBALL_SPORT_ID = Sport.FLOORBALL_SPORT_ID
+FOOTBALL_SPORT_ID = Sport.FOOTBALL_SPORT_ID
+FUTSAL_SPORT_ID = Sport.FUTSAL_SPORT_ID
+GOLF_SPORT_ID = Sport.GOLF_SPORT_ID
+HANDBALL_SPORT_ID = Sport.HANDBALL_SPORT_ID
+HOCKEY_SPORT_ID = Sport.HOCKEY_SPORT_ID
+HORSE_RACING_SPECIALS_SPORT_ID = Sport.HORSE_RACING_SPECIALS_SPORT_ID
+LACROSSE_SPORT_ID = Sport.LACROSSE_SPORT_ID
+MMA_SPORT_ID = Sport.MMA_SPORT_ID
+OTHER_SPORTS_SPORT_ID = Sport.OTHER_SPORTS_SPORT_ID
+POLITICS_SPORT_ID = Sport.POLITICS_SPORT_ID
+RUGBY_LEAGUE_SPORT_ID = Sport.RUGBY_LEAGUE_SPORT_ID
+RUGBY_UNION_SPORT_ID = Sport.RUGBY_UNION_SPORT_ID
+SNOOKER_SPORT_ID = Sport.SNOOKER_SPORT_ID
+SOCCER_SPORT_ID = Sport.SOCCER_SPORT_ID
+SOFTBALL_SPORT_ID = Sport.SOFTBALL_SPORT_ID
+SQUASH_SPORT_ID = Sport.SQUASH_SPORT_ID
+TABLE_TENNIS_SPORT_ID = Sport.TABLE_TENNIS_SPORT_ID
+TENNIS_SPORT_ID = Sport.TENNIS_SPORT_ID
+VOLLEYBALL_SPORT_ID = Sport.VOLLEYBALL_SPORT_ID
+WATER_POLO_SPORT_ID = Sport.WATER_POLO_SPORT_ID
+PADEL_TENNIS_SPORT_ID = Sport.PADEL_TENNIS_SPORT_ID
+AUSSIE_RULES_SPORT_ID = Sport.AUSSIE_RULES_SPORT_ID
+ALPINE_SKIING_SPORT_ID = Sport.ALPINE_SKIING_SPORT_ID
+BIATHLON_SPORT_ID = Sport.BIATHLON_SPORT_ID
+SKI_JUMPING_SPORT_ID = Sport.SKI_JUMPING_SPORT_ID
+CROSS_COUNTRY_SPORT_ID = Sport.CROSS_COUNTRY_SPORT_ID
+FORMULA1_SPORT_ID = Sport.FORMULA1_SPORT_ID
+CYCLING_SPORT_ID = Sport.CYCLING_SPORT_ID
+BOBSLEIGH_SPORT_ID = Sport.BOBSLEIGH_SPORT_ID
+FIGURE_SKATING_SPORT_ID = Sport.FIGURE_SKATING_SPORT_ID
+FREESTYLE_SKIING_SPORT_ID = Sport.FREESTYLE_SKIING_SPORT_ID
+LUGE_SPORT_ID = Sport.LUGE_SPORT_ID
+NORDIC_COMBINED_SPORT_ID = Sport.NORDIC_COMBINED_SPORT_ID
+SHORT_TRACK_SPORT_ID = Sport.SHORT_TRACK_SPORT_ID
+SKELETON_SPORT_ID = Sport.SKELETON_SPORT_ID
+SNOWBOARDING_SPORT_ID = Sport.SNOWBOARDING_SPORT_ID
+SPEED_SKATING_SPORT_ID = Sport.SPEED_SKATING_SPORT_ID
+OLYMPICS_SPORT_ID = Sport.OLYMPICS_SPORT_ID
+ATHLETICS_SPORT_ID = Sport.ATHLETICS_SPORT_ID
+CROSSFIT_SPORT_ID = Sport.CROSSFIT_SPORT_ID
+ENTERTAINMENT_SPORT_ID = Sport.ENTERTAINMENT_SPORT_ID
+ARCHERY_SPORT_ID = Sport.ARCHERY_SPORT_ID
+DRONE_RACING_SPORT_ID = Sport.DRONE_RACING_SPORT_ID
+POKER_SPORT_ID = Sport.POKER_SPORT_ID
+MOTORSPORT_SPORT_ID = Sport.MOTORSPORT_SPORT_ID
+SIMULATED_GAMES_SPORT_ID = Sport.SIMULATED_GAMES_SPORT_ID
+SUMO_SPORT_ID = Sport.SUMO_SPORT_ID
+
+
+SPORT_ID_TO_NAME: dict[Sport, str] = {
+    Sport.BADMINTON_SPORT_ID: "Badminton",
+    Sport.BANDY_SPORT_ID: "Bandy",
+    Sport.BASEBALL_SPORT_ID: "Baseball",
+    Sport.BASKETBALL_SPORT_ID: "Basketball",
+    Sport.BEACH_VOLLEYBALL_SPORT_ID: "Beach Volleyball",
+    Sport.BOXING_SPORT_ID: "Boxing",
+    Sport.CHESS_SPORT_ID: "Chess",
+    Sport.CRICKET_SPORT_ID: "Cricket",
+    Sport.CURLING_SPORT_ID: "Curling",
+    Sport.DARTS_SPORT_ID: "Darts",
+    Sport.FIELD_HOCKEY_SPORT_ID: "Field Hockey",
+    Sport.FLOORBALL_SPORT_ID: "Floorball",
+    Sport.FOOTBALL_SPORT_ID: "Football",
+    Sport.FUTSAL_SPORT_ID: "Futsal",
+    Sport.GOLF_SPORT_ID: "Golf",
+    Sport.HANDBALL_SPORT_ID: "Handball",
+    Sport.HOCKEY_SPORT_ID: "Hockey",
+    Sport.HORSE_RACING_SPECIALS_SPORT_ID: "Horse Racing Specials",
+    Sport.LACROSSE_SPORT_ID: "Lacrosse",
+    Sport.MMA_SPORT_ID: "Mixed Martial Arts",
+    Sport.OTHER_SPORTS_SPORT_ID: "Other Sports",
+    Sport.POLITICS_SPORT_ID: "Politics",
+    Sport.RUGBY_LEAGUE_SPORT_ID: "Rugby League",
+    Sport.RUGBY_UNION_SPORT_ID: "Rugby Union",
+    Sport.SNOOKER_SPORT_ID: "Snooker",
+    Sport.SOCCER_SPORT_ID: "Soccer",
+    Sport.SOFTBALL_SPORT_ID: "Softball",
+    Sport.SQUASH_SPORT_ID: "Squash",
+    Sport.TABLE_TENNIS_SPORT_ID: "Table Tennis",
+    Sport.TENNIS_SPORT_ID: "Tennis",
+    Sport.VOLLEYBALL_SPORT_ID: "Volleyball",
+    Sport.WATER_POLO_SPORT_ID: "Water Polo",
+    Sport.PADEL_TENNIS_SPORT_ID: "Padel Tennis",
+    Sport.AUSSIE_RULES_SPORT_ID: "Aussie Rules",
+    Sport.ALPINE_SKIING_SPORT_ID: "Alpine Skiing",
+    Sport.BIATHLON_SPORT_ID: "Biathlon",
+    Sport.SKI_JUMPING_SPORT_ID: "Ski Jumping",
+    Sport.CROSS_COUNTRY_SPORT_ID: "Cross Country",
+    Sport.FORMULA1_SPORT_ID: "Formula 1",
+    Sport.CYCLING_SPORT_ID: "Cycling",
+    Sport.BOBSLEIGH_SPORT_ID: "Bobsleigh",
+    Sport.FIGURE_SKATING_SPORT_ID: "Figure Skating",
+    Sport.FREESTYLE_SKIING_SPORT_ID: "Freestyle Skiing",
+    Sport.LUGE_SPORT_ID: "Luge",
+    Sport.NORDIC_COMBINED_SPORT_ID: "Nordic Combined",
+    Sport.SHORT_TRACK_SPORT_ID: "Short Track",
+    Sport.SKELETON_SPORT_ID: "Skeleton",
+    Sport.SNOWBOARDING_SPORT_ID: "Snow Boarding",
+    Sport.SPEED_SKATING_SPORT_ID: "Speed Skating",
+    Sport.OLYMPICS_SPORT_ID: "Olympics",
+    Sport.ATHLETICS_SPORT_ID: "Athletics",
+    Sport.CROSSFIT_SPORT_ID: "Crossfit",
+    Sport.ENTERTAINMENT_SPORT_ID: "Entertainment",
+    Sport.ARCHERY_SPORT_ID: "Archery",
+    Sport.DRONE_RACING_SPORT_ID: "Drone Racing",
+    Sport.POKER_SPORT_ID: "Poker",
+    Sport.MOTORSPORT_SPORT_ID: "Motorsport",
+    Sport.SIMULATED_GAMES_SPORT_ID: "Simulated Games",
+    Sport.SUMO_SPORT_ID: "Sumo",
+}
+
+
+__all__ = [
+    "Sport",
+    "SPORT_ID_TO_NAME",
+    "BADMINTON_SPORT_ID",
+    "BANDY_SPORT_ID",
+    "BASEBALL_SPORT_ID",
+    "BASKETBALL_SPORT_ID",
+    "BEACH_VOLLEYBALL_SPORT_ID",
+    "BOXING_SPORT_ID",
+    "CHESS_SPORT_ID",
+    "CRICKET_SPORT_ID",
+    "CURLING_SPORT_ID",
+    "DARTS_SPORT_ID",
+    "FIELD_HOCKEY_SPORT_ID",
+    "FLOORBALL_SPORT_ID",
+    "FOOTBALL_SPORT_ID",
+    "FUTSAL_SPORT_ID",
+    "GOLF_SPORT_ID",
+    "HANDBALL_SPORT_ID",
+    "HOCKEY_SPORT_ID",
+    "HORSE_RACING_SPECIALS_SPORT_ID",
+    "LACROSSE_SPORT_ID",
+    "MMA_SPORT_ID",
+    "OTHER_SPORTS_SPORT_ID",
+    "POLITICS_SPORT_ID",
+    "RUGBY_LEAGUE_SPORT_ID",
+    "RUGBY_UNION_SPORT_ID",
+    "SNOOKER_SPORT_ID",
+    "SOCCER_SPORT_ID",
+    "SOFTBALL_SPORT_ID",
+    "SQUASH_SPORT_ID",
+    "TABLE_TENNIS_SPORT_ID",
+    "TENNIS_SPORT_ID",
+    "VOLLEYBALL_SPORT_ID",
+    "WATER_POLO_SPORT_ID",
+    "PADEL_TENNIS_SPORT_ID",
+    "AUSSIE_RULES_SPORT_ID",
+    "ALPINE_SKIING_SPORT_ID",
+    "BIATHLON_SPORT_ID",
+    "SKI_JUMPING_SPORT_ID",
+    "CROSS_COUNTRY_SPORT_ID",
+    "FORMULA1_SPORT_ID",
+    "CYCLING_SPORT_ID",
+    "BOBSLEIGH_SPORT_ID",
+    "FIGURE_SKATING_SPORT_ID",
+    "FREESTYLE_SKIING_SPORT_ID",
+    "LUGE_SPORT_ID",
+    "NORDIC_COMBINED_SPORT_ID",
+    "SHORT_TRACK_SPORT_ID",
+    "SKELETON_SPORT_ID",
+    "SNOWBOARDING_SPORT_ID",
+    "SPEED_SKATING_SPORT_ID",
+    "OLYMPICS_SPORT_ID",
+    "ATHLETICS_SPORT_ID",
+    "CROSSFIT_SPORT_ID",
+    "ENTERTAINMENT_SPORT_ID",
+    "ARCHERY_SPORT_ID",
+    "DRONE_RACING_SPORT_ID",
+    "POKER_SPORT_ID",
+    "MOTORSPORT_SPORT_ID",
+    "SIMULATED_GAMES_SPORT_ID",
+    "SUMO_SPORT_ID",
+]

ps3838api/models/tank.py

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+
+class EventInfo(TypedDict):
+    leagueId: int
+    eventId: int

ps3838api/tank.py

@@ -0,0 +1,93 @@
+"""Centralised fixtures/odds caching that respects PS3838 rate‑limits.
+
+The core idea is identical for both resources:
+• ≥ 60 s since previous call → **snapshot** (full refresh)
+• 5–59 s                            → **delta** (incremental update, merged into cache)
+• < 5 s                             → **use in‑memory cache**, no API hit
+
+Odds were already following this contract.  Fixtures now do too.
+Additionally, fixtures are **no longer persisted** as one huge
+``fixtures.json`` file.  Every API response (snapshot *and* delta)
+gets stored verbatim in *temp/responses/* for replay/debugging just
+like odds.  If a full history is ever required you can reconstruct it
+from those files.
+"""
+
+import json
+import logging
+import warnings
+from pathlib import Path
+from time import time
+
+from ps3838api.api.client import PinnacleClient
+from ps3838api.matching import MATCHED_LEAGUES
+from ps3838api.models.fixtures import FixturesResponse
+from ps3838api.utils.ops import merge_fixtures
+
+warnings.warn(
+    f"{__name__} is experimental, incomplete, and may change in future versions.",
+    UserWarning,
+)
+
+
+SNAPSHOT_INTERVAL = 60
+DELTA_INTERVAL = 5
+
+
+TOP_LEAGUES = [league["ps3838_id"] for league in MATCHED_LEAGUES if league["ps3838_id"]]
+
+logger = logging.getLogger(__name__)
+
+
+class FixtureTank:
+    """Lightweight cache for Pinnacle *fixtures*.
+
+    * No big persisted file – only individual API responses are archived.
+    * Shares the same timing policy as :class:`OddsTank`.
+    """
+
+    def __init__(
+        self,
+        client: PinnacleClient,
+        league_ids: list[int] | None = None,
+        response_dir: Path | str | None = None,  # Path("temp/responses")
+    ) -> None:
+        self.client = client
+        self.response_dir = Path(response_dir) if response_dir else None
+        # start with a fresh snapshot (fast + guarantees consistency)
+        self.data: FixturesResponse = client.get_fixtures(league_ids=league_ids)
+        self._last_call_time = time()
+        self._save_response(self.data, snapshot=True)
+
+    def _save_response(self, response_data: FixturesResponse, snapshot: bool) -> None:
+        """
+        Save fixture response to the temp/responses folder for future testing.
+        """
+        if not self.response_dir:
+            return
+        kind = "snapshot" if snapshot else "delta"
+        self.response_dir.mkdir(parents=True, exist_ok=True)
+        fn = self.response_dir / f"fixtures_{kind}_{int(time())}.json"
+        with open(fn, "w") as f:
+            json.dump(response_data, f, indent=4)
+
+    def update(self) -> None:
+        """Refresh internal cache if timing thresholds are met."""
+        now = time()
+        elapsed = now - self._last_call_time
+
+        if elapsed < DELTA_INTERVAL:
+            return  # 💡 Too soon – use cached data
+
+        if elapsed >= SNAPSHOT_INTERVAL:
+            # ── Full refresh ────────────────────────────────────────────
+            resp = self.client.get_fixtures()
+            self.data = resp
+            self._save_response(resp, snapshot=True)
+        else:
+            # ── Incremental update ──────────────────────────────────────
+            delta = self.client.get_fixtures(since=self.data["last"])
+            self.data = merge_fixtures(self.data, delta)
+            self._save_response(delta, snapshot=False)
+
+        self._last_call_time = now

ps3838api/totals.py

@@ -0,0 +1,62 @@
+import warnings
+from typing import cast
+
+from ps3838api.models.odds import OddsEventV3, OddsTotalV3
+
+warnings.warn(
+    f"{__name__} is experimental and its interface is not stable yet.",
+    FutureWarning,
+)
+
+
+class OddsTotal(OddsTotalV3):
+    """Has line id"""
+
+    lineId: int
+
+
+def calculate_margin(total: OddsTotalV3) -> float:
+    return (1 / total["over"] + 1 / total["under"]) - 1
+
+
+def get_all_total_lines(
+    odds: OddsEventV3,
+    periods: list[int] = [
+        0,
+    ],
+) -> list[OddsTotal]:
+    result: list[OddsTotal] = []
+    for period in odds["periods"]:  # type: ignore
+        if "number" not in period:
+            # skip if unknown period
+            continue
+        if period["number"] not in periods:
+            # skip if wrong periood
+            continue
+        if "totals" not in period:
+            # skip if no totals in this period
+            continue
+        if "lineId" not in period:
+            # skip if don't have lineId
+            continue
+
+        lineId = period["lineId"]
+        maxTotal = period["maxTotal"] if "maxTotal" in period else None
+
+        for total in period["totals"]:
+            odds_total = cast(OddsTotal, total.copy())
+            odds_total["lineId"] = lineId
+            # each total should have lineId
+
+            if "altLineId" not in total:
+                if maxTotal is not None:
+                    odds_total["max"] = maxTotal
+            result.append(odds_total)
+    return result
+
+
+def get_best_total_line(odds: OddsEventV3, periods: list[int] = [0, 1]) -> OddsTotal | None:
+    try:
+        return min(get_all_total_lines(odds, periods=periods), key=calculate_margin)
+    except Exception:
+        return None

ps3838api/utils/match_leagues.py

@@ -0,0 +1,90 @@
+# type: ignore
+import json
+from pathlib import Path
+from typing import Any
+
+from rapidfuzz import fuzz, process
+
+from ps3838api import ROOT_MODULE_DIR
+
+
+# Your threshold-based fuzzy function
+def is_leagues_match(league1: str, league2: str, threshold: int = 80) -> bool:
+    """
+    Returns True if leagues are a fuzzy match with a token sort ratio >= threshold.
+    fuzz.token_sort_ratio() returns 0-100, so 80 means 80% similar.
+    """
+    return fuzz.token_sort_ratio(league1, league2) >= threshold
+
+
+def load_json(path: str | Path) -> list[Any] | dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def main():
+    betsapi_path = ROOT_MODULE_DIR / Path("out/betsapi_leagues.json")
+    ps3838_path = ROOT_MODULE_DIR / Path("out/ps3838_leagues.json")
+    output_path = ROOT_MODULE_DIR / Path("out/matched_leagues.json")
+
+    # --------------------------------------------------------------------
+    # Load raw data
+    # --------------------------------------------------------------------
+    betsapi_leagues = load_json(betsapi_path)  # e.g. ["Premier League", "La Liga", ...]
+    ps3838_data = load_json(ps3838_path)
+    # --------------------------------------------------------------------
+    # Build a RapidFuzz index of PS3838 league names to do quick "best-match" lookups
+    # --------------------------------------------------------------------
+    # 1) Just keep a list of league names:
+    ps_names = [league["name"] for league in ps3838_data]
+
+    # 2) Also map name -> (full record) for easy ID lookup:
+    ps_map = {league["name"]: league for league in ps3838_data}
+
+    # --------------------------------------------------------------------
+    # Compare each BetsAPI league to the best PS3838 league match
+    # --------------------------------------------------------------------
+    matched = []
+    for betsapi_league in betsapi_leagues:
+        # RapidFuzz: find the single best match
+        # extractOne returns a tuple: (best_match_string, score, index)
+        best_match = process.extractOne(betsapi_league, ps_names, scorer=fuzz.token_sort_ratio)
+
+        if best_match is not None:
+            ps_name, score, _ = best_match
+            if score >= 80:
+                # It's a good fuzzy match
+                matched_league_info = {
+                    "betsapi_league": betsapi_league,
+                    "ps3838_league": ps_map[ps_name]["name"],
+                    "ps3838_id": ps_map[ps_name]["id"],
+                }
+            else:
+                # We got a best match but it's below threshold
+                matched_league_info = {
+                    "betsapi_league": betsapi_league,
+                    "ps3838_league": None,
+                    "ps3838_id": None,
+                }
+        else:
+            # No match at all
+            matched_league_info = {
+                "betsapi_league": betsapi_league,
+                "ps3838_league": None,
+                "ps3838_id": None,
+            }
+
+        matched.append(matched_league_info)
+
+    # --------------------------------------------------------------------
+    # Save output
+    # --------------------------------------------------------------------
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(matched, f, indent=2, ensure_ascii=False)
+
+    print(f"✅ Matching complete. Output saved to: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

ps3838api/utils/ops.py

@@ -0,0 +1,146 @@
+import warnings
+
+from ps3838api.models.event import NoSuchLeagueFixtures, NoSuchOddsAvailable
+from ps3838api.models.fixtures import FixturesLeagueV3, FixturesResponse, FixtureV3
+from ps3838api.models.odds import OddsEventV3, OddsLeagueV3, OddsResponse
+from ps3838api.models.tank import EventInfo
+
+warnings.warn(
+    f"{__name__} is experimental, incomplete, and may change in future versions.",
+    UserWarning,
+)
+
+
+def merge_odds_response(old: OddsResponse, new: OddsResponse) -> OddsResponse:
+    """
+    Merge a snapshot OddsResponse (old) with a delta OddsResponse (new).
+    - Leagues are matched by league["id"].
+    - Events are matched by event["id"].
+    - Periods are matched by period["number"].
+    - Any period present in 'new' entirely replaces the same period number in 'old'.
+    - Periods not present in 'new' remain as they were in 'old'.
+
+    Returns a merged OddsResponse that includes updated odds and periods, retaining
+    old entries when no changes were reported in the delta.
+
+    Based on "How to get odds changes?" from https://ps3838api.github.io/FAQs.html
+    """
+    # Index the old leagues by their IDs
+    league_index: dict[int, OddsLeagueV3] = {league["id"]: league for league in old.get("leagues", [])}
+
+    # Loop through the new leagues
+    for new_league in new.get("leagues", []):
+        lid = new_league["id"]
+
+        # If it's an entirely new league, just store it
+        if lid not in league_index:
+            league_index[lid] = new_league
+            continue
+
+        # Otherwise merge it with the existing league
+        old_league = league_index[lid]
+        old_event_index = {event["id"]: event for event in old_league.get("events", [])}
+
+        # Loop through the new events
+        for new_event in new_league.get("events", []):
+            eid = new_event["id"]
+
+            # If it's an entirely new event, just store it
+            if eid not in old_event_index:
+                old_event_index[eid] = new_event
+                continue
+
+            # Otherwise, merge with the existing event
+            old_event = old_event_index[eid]
+
+            # Periods: build an index by 'number' from the old event
+            old_period_index = {p["number"]: p for p in old_event.get("periods", []) if "number" in p}
+
+            # Take all the new event's periods and override or insert them by 'number'
+            for new_period in new_event.get("periods", []):
+                if "number" not in new_period:
+                    continue
+                old_period_index[new_period["number"]] = new_period
+
+            # Merge top-level fields: new event fields override old ones
+            merged_event = old_event.copy()
+            merged_event.update(new_event)
+
+            # Rebuild the merged_event's periods from the updated dictionary
+            merged_event["periods"] = list(old_period_index.values())
+
+            # Store back in the event index
+            old_event_index[eid] = merged_event
+
+        # Rebuild league's events list from the merged event index
+        old_league["events"] = list(old_event_index.values())
+
+    return {
+        "sportId": new.get("sportId", old["sportId"]),
+        # Always take the latest `last` timestamp from the new (delta) response
+        "last": new["last"],
+        # Rebuild leagues list
+        "leagues": list(league_index.values()),
+    }
+
+
+def merge_fixtures(old: FixturesResponse, new: FixturesResponse) -> FixturesResponse:
+    league_index: dict[int, FixturesLeagueV3] = {league["id"]: league for league in old.get("league", [])}
+
+    for new_league in new.get("league", []):
+        lid = new_league["id"]
+        if lid in league_index:
+            old_events = {e["id"]: e for e in league_index[lid]["events"]}
+            for event in new_league["events"]:
+                old_events[event["id"]] = event  # override or insert
+            league_index[lid]["events"] = list(old_events.values())
+        else:
+            league_index[lid] = new_league  # new league entirely
+    return {
+        "sportId": new.get("sportId", old["sportId"]),
+        "last": new["last"],
+        "league": list(league_index.values()),
+    }
+
+
+def find_league_in_fixtures(
+    fixtures: FixturesResponse, league: str, league_id: int
+) -> FixturesLeagueV3 | NoSuchLeagueFixtures:
+    for leagueV3 in fixtures["league"]:
+        if leagueV3["id"] == league_id:
+            return leagueV3
+    else:
+        return NoSuchLeagueFixtures(league)
+
+
+def find_fixtureV3_in_league(leagueV3: FixturesLeagueV3, event_id: int) -> FixtureV3:
+    for eventV3 in leagueV3["events"]:
+        if eventV3["id"] == event_id:
+            return eventV3
+    raise ValueError("No such event")
+
+
+def filter_odds(
+    odds: OddsResponse, event_id: int, league_id: int | None = None
+) -> OddsEventV3 | NoSuchOddsAvailable:
+    """passing `league_id` makes search in json faster"""
+    for league in odds["leagues"]:
+        if league_id and league_id != league["id"]:
+            continue
+        for fixture in league["events"]:
+            if fixture["id"] == event_id:
+                return fixture
+    return NoSuchOddsAvailable(event_id)
+
+
+def normalize_to_set(name: str) -> set[str]:
+    return set(name.replace(" II", " 2").replace(" I", "").lower().replace("-", " ").split())
+
+
+def find_event_by_id(fixtures: FixturesResponse, event: EventInfo) -> FixtureV3 | None:
+    for leagueV3 in fixtures["league"]:
+        if leagueV3["id"] == event["leagueId"]:
+            for fixtureV3 in leagueV3["events"]:
+                if fixtureV3["id"] == event["eventId"]:
+                    return fixtureV3
+    return None