ps3838api 1.1.0__py3-none-any.whl

ps3838api/api/default_client.py

@@ -0,0 +1,231 @@
+"""
+Legacy helper functions that use a shared default :class:`Client`.
+"""
+
+import sys
+import warnings
+from datetime import datetime
+from typing import Any, Literal
+
+if sys.version_info >= (3, 13):
+    from warnings import deprecated
+else:
+
+    def deprecated(reason: str):  # type: ignore
+        def decorator(func):  # type: ignore
+            def wrapper(*args, **kwargs):  # type: ignore
+                warnings.warn(
+                    f"{func.__name__} is deprecated: {reason}",  # type: ignore
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                return func(*args, **kwargs)  # type: ignore
+
+            wrapper.__name__ = func.__name__  # type: ignore
+            wrapper.__doc__ = func.__doc__  # type: ignore
+            wrapper.__dict__.update(func.__dict__)  # type: ignore
+            return wrapper  # type: ignore
+
+        return decorator  # type: ignore
+
+
+from ps3838api.models.bets import BetType, FillType, OddsFormat, PlaceStraightBetResponse, Side, Team
+from ps3838api.models.client import BalanceData, BettingStatusResponse, LeagueV3, PeriodData
+from ps3838api.models.fixtures import FixturesResponse
+from ps3838api.models.lines import LineResponse
+from ps3838api.models.odds import OddsResponse
+from ps3838api.models.sports import SOCCER_SPORT_ID
+
+from .client import PinnacleClient
+
+_default_client: PinnacleClient | None = None
+
+
+def _get_default_client() -> PinnacleClient:
+    global _default_client  # noqa: PLW0603
+    if _default_client is None:
+        _default_client = PinnacleClient()
+    return _default_client
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_client_balance() -> BalanceData:
+    return _get_default_client().get_client_balance()
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_periods(sport_id: int | None = None) -> list[PeriodData]:
+    return _get_default_client().get_periods(sport_id=sport_id)
+
+
+@deprecated("Use `ps3838api.models.sports` sports constant")
+def get_sports() -> Any:
+    return _get_default_client().get_sports()
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_leagues(sport_id: int | None = None) -> list[LeagueV3]:
+    return _get_default_client().get_leagues(sport_id=sport_id)
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_fixtures(
+    sport_id: int | None = None,
+    league_ids: list[int] | None = None,
+    is_live: bool | None = None,
+    since: int | None = None,
+    event_ids: list[int] | None = None,
+    settled: bool = False,
+) -> FixturesResponse:
+    return _get_default_client().get_fixtures(
+        sport_id=sport_id,
+        league_ids=league_ids,
+        is_live=is_live,
+        since=since,
+        event_ids=event_ids,
+        settled=settled,
+    )
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_odds(
+    sport_id: int | None = None,
+    is_special: bool = False,
+    league_ids: list[int] | None = None,
+    odds_format: OddsFormat = "DECIMAL",
+    since: int | None = None,
+    is_live: bool | None = None,
+    event_ids: list[int] | None = None,
+) -> OddsResponse:
+    return _get_default_client().get_odds(
+        sport_id=sport_id,
+        is_special=is_special,
+        league_ids=league_ids,
+        odds_format=odds_format,
+        since=since,
+        is_live=is_live,
+        event_ids=event_ids,
+    )
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_special_fixtures(
+    sport_id: int | None = None,
+    league_ids: list[int] | None = None,
+    event_id: int | None = None,
+) -> Any:
+    return _get_default_client().get_special_fixtures(
+        sport_id=sport_id, league_ids=league_ids, event_id=event_id
+    )
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_line(
+    league_id: int,
+    event_id: int,
+    period_number: int,
+    bet_type: Literal["SPREAD", "MONEYLINE", "TOTAL_POINTS", "TEAM_TOTAL_POINTS"],
+    handicap: float,
+    team: Literal["Team1", "Team2", "Draw"] | None = None,
+    side: Literal["OVER", "UNDER"] | None = None,
+    sport_id: int | None = None,
+    odds_format: str = "Decimal",
+) -> LineResponse:
+    return _get_default_client().get_line(
+        league_id=league_id,
+        event_id=event_id,
+        period_number=period_number,
+        bet_type=bet_type,
+        handicap=handicap,
+        team=team,
+        side=side,
+        sport_id=sport_id,
+        odds_format=odds_format,
+    )
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def place_straigh_bet(
+    *,
+    stake: float,
+    event_id: int,
+    bet_type: BetType,
+    line_id: int | None,
+    period_number: int = 0,
+    sport_id: int = SOCCER_SPORT_ID,
+    alt_line_id: int | None = None,
+    unique_request_id: str | None = None,
+    odds_format: OddsFormat = "DECIMAL",
+    fill_type: FillType = "NORMAL",
+    accept_better_line: bool = True,
+    win_risk_stake: Literal["WIN", "RISK"] = "RISK",
+    pitcher1_must_start: bool = True,
+    pitcher2_must_start: bool = True,
+    team: Team | None = None,
+    side: Side | None = None,
+    handicap: float | None = None,
+) -> PlaceStraightBetResponse:
+    return _get_default_client().place_straight_bet(
+        stake=stake,
+        event_id=event_id,
+        bet_type=bet_type,
+        line_id=line_id,
+        period_number=period_number,
+        sport_id=sport_id,
+        alt_line_id=alt_line_id,
+        unique_request_id=unique_request_id,
+        odds_format=odds_format,
+        fill_type=fill_type,
+        accept_better_line=accept_better_line,
+        win_risk_stake=win_risk_stake,
+        pitcher1_must_start=pitcher1_must_start,
+        pitcher2_must_start=pitcher2_must_start,
+        team=team,
+        side=side,
+        handicap=handicap,
+    )
+
+
+@deprecated("Use `ps3838api.client.PinnacleClient` base methods")
+def get_betting_status() -> BettingStatusResponse:
+    return _get_default_client().get_betting_status()
+
+
+def export_my_bets(
+    *,
+    from_datetime: datetime,
+    to_datetime: datetime,
+    d: int = -1,
+    status: Literal["UNSETTLED", "SETTLED"] = "SETTLED",
+    sd: bool = False,
+    bet_type: str = "WAGER",
+    product: str = "SB,PP,BG",
+    locale: str = "en_US",
+    timezone: str = "GMT-4",
+) -> bytes:
+    return _get_default_client().export_my_bets(
+        from_datetime=from_datetime,
+        to_datetime=to_datetime,
+        d=d,
+        status=status,
+        sd=sd,
+        bet_type=bet_type,
+        product=product,
+        locale=locale,
+        timezone=timezone,
+    )
+
+
+__all__ = [
+    "get_client_balance",
+    "get_periods",
+    "get_sports",
+    "get_leagues",
+    "get_fixtures",
+    "get_odds",
+    "get_special_fixtures",
+    "get_line",
+    "place_straigh_bet",
+    "get_betting_status",
+    "export_my_bets",
+]

ps3838api/api/v4client.py

@@ -0,0 +1,107 @@
+from typing import TYPE_CHECKING, Any, cast
+
+from ps3838api.models.bets import OddsFormat
+from ps3838api.models.odds import OddsResponseV4
+
+if TYPE_CHECKING:
+    # to avoid ciruclar imports
+    from ps3838api.api.client import PinnacleClient
+
+
+class V4PinnacleClient:
+    """Subclient for V4 API endpoints.
+
+    V4 endpoints provide enhanced responses, particularly for team totals
+    which return arrays of alternative lines instead of single objects.
+    """
+
+    def __init__(self, client: "PinnacleClient"):
+        self._client = client
+
+    def get_odds(
+        self,
+        sport_id: int | None = None,
+        league_ids: list[int] | None = None,
+        odds_format: OddsFormat = "DECIMAL",
+        since: int | None = None,
+        is_live: bool | None = None,
+        event_ids: list[int] | None = None,
+        to_currency_code: str | None = None,
+    ) -> OddsResponseV4:
+        """Get straight odds for non-settled events using V4 endpoint.
+
+        V4 returns enhanced team total data with arrays of alternative lines.
+
+        Args:
+            sport_id: Sport ID. Uses client's default_sport if not provided.
+            league_ids: List of league IDs to filter.
+            odds_format: Format for odds (DECIMAL, AMERICAN, etc.).
+            since: Used for incremental updates. Use 'last' from previous response.
+            is_live: True for live events only, False for prematch only.
+            event_ids: List of event IDs to filter.
+            to_currency_code: Convert limits to specified currency.
+
+        Returns:
+            OddsResponseV4 containing odds data with V4 enhanced structure.
+        """
+        endpoint = "/v4/odds"
+
+        resolved_sport_id = sport_id if sport_id is not None else self._client.default_sport
+
+        params: dict[str, Any] = {
+            "sportId": resolved_sport_id,
+            "oddsFormat": odds_format,
+        }
+        if league_ids:
+            params["leagueIds"] = ",".join(map(str, league_ids))
+        if since is not None:
+            params["since"] = since
+        if is_live is not None:
+            params["isLive"] = int(is_live)
+        if event_ids:
+            params["eventIds"] = ",".join(map(str, event_ids))
+        if to_currency_code is not None:
+            params["toCurrencyCode"] = to_currency_code
+
+        return cast(OddsResponseV4, self._client._get(endpoint, params))  # pyright: ignore[reportPrivateUsage]
+
+    def get_parlay_odds(
+        self,
+        sport_id: int | None = None,
+        league_ids: list[int] | None = None,
+        odds_format: OddsFormat = "DECIMAL",
+        since: int | None = None,
+        is_live: bool | None = None,
+        event_ids: list[int] | None = None,
+    ) -> OddsResponseV4:
+        """Get parlay odds for non-settled events using V4 endpoint.
+
+        Args:
+            sport_id: Sport ID. Uses client's default_sport if not provided.
+            league_ids: List of league IDs to filter.
+            odds_format: Format for odds (DECIMAL, AMERICAN, etc.).
+            since: Used for incremental updates. Use 'last' from previous response.
+            is_live: True for live events only, False for prematch only.
+            event_ids: List of event IDs to filter.
+
+        Returns:
+            OddsResponseV4 containing parlay odds data.
+        """
+        endpoint = "/v4/odds/parlay"
+
+        resolved_sport_id = sport_id if sport_id is not None else self._client.default_sport
+
+        params: dict[str, Any] = {
+            "sportId": resolved_sport_id,
+            "oddsFormat": odds_format,
+        }
+        if league_ids:
+            params["leagueIds"] = ",".join(map(str, league_ids))
+        if since is not None:
+            params["since"] = since
+        if is_live is not None:
+            params["isLive"] = int(is_live)
+        if event_ids:
+            params["eventIds"] = ",".join(map(str, event_ids))
+
+        return cast(OddsResponseV4, self._client._get(endpoint, params))  # pyright: ignore[reportPrivateUsage]

ps3838api/matching.py

@@ -0,0 +1,141 @@
+import json
+import warnings
+from typing import Final, Literal
+
+from rapidfuzz import fuzz
+
+import ps3838api.api as ps
+from ps3838api import ROOT_MODULE_DIR
+from ps3838api.models.event import (
+    Failure,
+    MatchedLeague,
+    NoSuchEvent,
+    NoSuchLeague,
+    NoSuchLeagueFixtures,
+    NoSuchLeagueMatching,
+    WrongLeague,
+)
+from ps3838api.models.fixtures import FixturesLeagueV3, FixturesResponse
+from ps3838api.models.tank import EventInfo
+from ps3838api.utils.ops import normalize_to_set
+
+warnings.warn(
+    f"{__name__} is experimental and its interface is not stable yet.",
+    FutureWarning,
+)
+
+with open(ROOT_MODULE_DIR / "out/matched_leagues.json") as file:
+    MATCHED_LEAGUES: Final[list[MatchedLeague]] = json.load(file)
+
+with open(ROOT_MODULE_DIR / "out/ps3838_leagues.json") as file:
+    ALL_LEAGUES: Final[list[ps.LeagueV3]] = json.load(file)["leagues"]
+
+
+def match_league(
+    *,
+    league_betsapi: str,
+    leagues_mapping: list[MatchedLeague] = MATCHED_LEAGUES,
+) -> MatchedLeague | NoSuchLeagueMatching | WrongLeague:
+    for league in leagues_mapping:
+        if league["betsapi_league"] == league_betsapi:
+            if league["ps3838_id"]:
+                return league
+            else:
+                return NoSuchLeagueMatching(league_betsapi)
+    return WrongLeague(league_betsapi)
+
+
+def find_league_by_name(league: str, leagues: list[ps.LeagueV3] = ALL_LEAGUES) -> ps.LeagueV3 | NoSuchLeague:
+    normalized = normalize_to_set(league)
+    for leagueV3 in leagues:
+        if normalize_to_set(leagueV3["name"]) == normalized:
+            return leagueV3
+    return NoSuchLeagueMatching(league)
+
+
+def find_event_in_league(
+    league_data: FixturesLeagueV3,
+    league: str,
+    home: str,
+    away: str,
+    live_status: Literal["PREMATCH", "LIVE"] | None = "PREMATCH",
+) -> EventInfo | NoSuchEvent:
+    """
+    If live_status is "LIVE", search only for events with a parentId.
+    This does not necessarily mean the event is live — it could also be a corners subevent.
+
+    If live_status is "PREMATCH", search only for events without a parentId.
+    Some prematch events (e.g. corners leagues) will be skipped.
+
+    Scans `league_data["events"]` for the best fuzzy match to `home` and `away`.
+    Returns the matching event with the highest sum of match scores, as long as
+    that sum >= 75 (which is 37.5% of the max possible 200).
+    Otherwise, returns NoSuchEvent.
+    """
+    best_event = None
+    best_sum_score = 0
+    for event in league_data["events"]:
+        match (live_status, "parentId" in event):
+            case None, _:
+                pass
+            case "PREMATCH", False:
+                pass
+            case "LIVE", True:
+                pass
+            case _:
+                continue
+
+        # Compare the user-provided home and away vs. the fixture's home and away.
+        # Using token_set_ratio (see below for comparison vs token_sort_ratio).
+        score_home = fuzz.token_set_ratio(home, event.get("home", ""))
+        score_away = fuzz.token_set_ratio(away, event.get("away", ""))
+        total_score = score_home + score_away
+        if total_score > best_sum_score:
+            best_sum_score = total_score
+            best_event = event
+    # If the best event's combined fuzzy match is < 37.5% of the total possible 200,
+    # treat it as no match:
+    if best_event is None or best_sum_score < 75:
+        return NoSuchEvent(league, home, away)
+    return {"eventId": best_event["id"], "leagueId": league_data["id"]}
+
+
+def magic_find_event(
+    fixtures: FixturesResponse,
+    league: str,
+    home: str,
+    away: str,
+    live_status: Literal["PREMATCH", "LIVE"] | None = "PREMATCH",
+) -> EventInfo | Failure:
+    """
+    1. Tries to find league by normalizng names;
+    2. If don't, search for a league matching
+    3. Then `find_event_in_league`
+
+    If live_status is "LIVE", search only for events with a parentId.
+    This does not necessarily mean the event is live — it could also be a corners subevent.
+
+    If live_status is "PREMATCH", search only for events without a parentId.
+    Some prematch events (e.g. corners leagues) will be skipped.
+
+    If live_status is None, search for any.
+
+    """
+
+    leagueV3 = find_league_by_name(league)
+    if isinstance(leagueV3, NoSuchLeague):
+        match match_league(league_betsapi=league):
+            case {"ps3838_id": int()} as value:
+                league_id: int = value["ps3838_id"]  # type: ignore
+            case _:
+                return NoSuchLeagueMatching(league)
+    else:
+        league_id = leagueV3["id"]
+
+    for leagueV3 in fixtures["league"]:
+        if leagueV3["id"] == league_id:
+            break
+    else:
+        return NoSuchLeagueFixtures(league)
+
+    return find_event_in_league(leagueV3, league, home, away, live_status)