ps3838api 0.1.0__py3-none-any.whl

ps3838api/tank.py

@@ -0,0 +1,237 @@
+from dataclasses import dataclass, field
+import datetime
+import json
+from pathlib import Path
+from time import time
+
+import ps3838api.api as ps
+
+from ps3838api.logic import (
+    filter_odds,
+    find_fixtureV3_in_league,
+    find_league_in_fixtures,
+    merge_fixtures,
+    merge_odds_response,
+)
+from ps3838api.matching import find_event_in_league, match_league, MATCHED_LEAGUES
+
+from ps3838api.models.tank import EventInfo
+from ps3838api.models.fixtures import FixturesResponse
+from ps3838api.models.odds import OddsEventV3, OddsResponse
+from ps3838api.models.event import (
+    EventTooFarInFuture,
+    Failure,
+    NoResult,
+    NoSuchEvent,
+    NoSuchLeague,
+)
+
+
+SNAPSHOT_INTERVAL = 60  # 1 minute
+DELTA_INTERVAL = 5  # 5 seconds
+
+RESPONSES_DIR = Path("temp/responses")
+RESPONSES_DIR.mkdir(parents=True, exist_ok=True)
+
+TOP_LEAGUES = [league["ps3838_id"] for league in MATCHED_LEAGUES if league["ps3838_id"]]
+
+
+class FixtureTank:
+    """
+    Stores ps3838 fixtures in a local JSON file, updating either via
+    a full snapshot or a delta call, depending on time elapsed since last call.
+    """
+
+    def __init__(
+        self,
+        league_ids: list[int] | None = None,
+        file_path: str | Path = "temp/fixtures.json",
+    ) -> None:
+        self.file_path = Path(file_path)
+        self.last_call_time = 0.0
+
+        # Load local cache or pull a snapshot from the API if file not found
+        try:
+            with open(self.file_path) as file:
+                self.data: FixturesResponse = json.load(file)
+        except FileNotFoundError:
+            self.data: FixturesResponse = ps.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.
+        """
+        kind = "snapshot" if snapshot else "delta"
+        timestamp = int(time())
+        filename = RESPONSES_DIR / f"fixtures_{kind}_{timestamp}.json"
+        with open(filename, "w") as f:
+            json.dump(response_data, f, indent=4)
+
+    def update(self):
+        """
+        Decide whether to make a snapshot call, delta call, or do nothing,
+        based on how much time has elapsed since the last call.
+        """
+        now = time()
+        elapsed = now - self.last_call_time
+
+        if elapsed < DELTA_INTERVAL:
+            # Less than 5 seconds → do nothing
+            return
+
+        if elapsed >= SNAPSHOT_INTERVAL:
+            # More than 1 minute → snapshot call
+            response = ps.get_fixtures(ps.SOCCER_SPORT_ID)
+            self.data = response
+            self._save_response(response, snapshot=True)
+
+        else:
+            # [5, 60) → delta call
+            delta = ps.get_fixtures(ps.SOCCER_SPORT_ID, since=self.data["last"])
+            self.data = merge_fixtures(self.data, delta)
+            self._save_response(delta, snapshot=False)
+
+        self.last_call_time = now
+
+    def save(self):
+        """
+        Save the current fixture data to fixtures.json (the local cache).
+        """
+        with open(self.file_path, "w") as file:
+            json.dump(self.data, file, indent=4)
+
+
+class OddsTank:
+    """
+    Stores ps3838 odds in a local JSON file, updating either via
+    a full snapshot or a delta call, depending on time elapsed since last call.
+    """
+
+    def __init__(
+        self,
+        league_ids: list[int] | None = None,
+        file_path: str | Path = "temp/odds.json",
+    ) -> None:
+        self.file_path = Path(file_path)
+        self.last_call_time = 0.0
+        self.is_live: bool | None = None
+
+        # Load local cache or pull a snapshot from the API if file not found
+        try:
+            with open(file_path) as file:
+                self.data: OddsResponse = json.load(file)
+        except FileNotFoundError:
+            self.data: OddsResponse = ps.get_odds(league_ids=league_ids)
+            self.last_call_time = time()
+            self._save_response(self.data, snapshot=True)
+
+    def _save_response(self, response_data: OddsResponse, snapshot: bool) -> None:
+        """
+        Save odds response to the temp/responses folder for future testing.
+        """
+        kind = "snapshot" if snapshot else "delta"
+        timestamp = int(time())
+        filename = RESPONSES_DIR / f"odds_{kind}_{timestamp}.json"
+        with open(filename, "w") as f:
+            json.dump(response_data, f, indent=4)
+
+    def update(self):
+        """
+        Decide whether to make a snapshot call, delta call, or do nothing,
+        based on how much time has elapsed since the last call.
+        """
+        now = time()
+        elapsed = now - self.last_call_time
+
+        if elapsed < DELTA_INTERVAL:
+            # Less than 5 seconds → do nothing
+            return
+
+        if elapsed >= SNAPSHOT_INTERVAL:
+            # More than 1 minute → snapshot call
+            response = ps.get_odds(ps.SOCCER_SPORT_ID, is_live=self.is_live)
+            self.data = response
+            self._save_response(response, snapshot=True)
+
+        else:
+            # [5, 60) → delta call
+            delta = ps.get_odds(
+                ps.SOCCER_SPORT_ID, is_live=self.is_live, since=self.data["last"]
+            )
+            self.data = merge_odds_response(self.data, delta)
+            self._save_response(delta, snapshot=False)
+
+        self.last_call_time = now
+
+    def save(self):
+        """
+        Save the current odds data to odds.json (the local cache).
+        """
+        with open(self.file_path, "w") as file:
+            json.dump(self.data, file, indent=4)
+
+
+
+@dataclass
+class EventMatcher:
+    fixtures: FixtureTank = field(init=False)
+    odds: OddsTank = field(init=False)
+    league_ids: list[int] | None = None
+
+    def __post_init__(self):
+        self.fixtures = FixtureTank(league_ids=self.league_ids)
+        self.odds = OddsTank(league_ids=self.league_ids)
+
+    def save(self):
+        self.fixtures.save()
+        self.odds.save()
+
+    def get_league_id_and_event_id(
+        self, league: str, home: str, away: str, force_local: bool = False
+    ) -> EventInfo | Failure:
+        match match_league(league_betsapi=league):
+            case NoSuchLeague() as f:
+                return f
+            case matched_league:
+                league_id = matched_league["ps3838_id"]
+                assert league_id is not None
+
+        leagueV3 = find_league_in_fixtures(self.fixtures.data, league, league_id)
+
+        if isinstance(leagueV3, NoSuchLeague):
+            if force_local:
+                return leagueV3
+            print("updating fixtures...")
+            self.fixtures.update()
+            leagueV3 = find_league_in_fixtures(self.fixtures.data, league, league_id)
+            if isinstance(leagueV3, NoSuchLeague):
+                return leagueV3
+
+        match find_event_in_league(leagueV3, league, home, away):
+            case NoSuchEvent() as f:
+                return f
+            case event:
+                event = event
+        fixture = find_fixtureV3_in_league(leagueV3, event['eventId'])
+
+        if 'starts' in fixture:
+            fixture_start = datetime.datetime.fromisoformat(fixture['starts'])
+            now = datetime.datetime.now(datetime.timezone.utc)
+            time_diff = fixture_start - now
+            # Check if the event starts in 60 minutes or less, but not in the past
+            if datetime.timedelta(0) <= time_diff <= datetime.timedelta(minutes=60):
+                return event
+        return EventTooFarInFuture(league, home, away)
+
+    def get_odds(
+        self, event: EventInfo, force_local: bool = False
+    ) -> OddsEventV3 | NoResult:
+        """
+        Update the odds tank and then look up the odds for the given event.
+        """
+        if not force_local:
+            self.odds.update()
+            self.save()
+        return filter_odds(self.odds.data, event["eventId"])

ps3838api/totals.py

@@ -0,0 +1,52 @@
+from typing import cast
+from typing import NotRequired
+from ps3838api.models.odds import OddsTotalV3, OddsEventV3
+
+
+class OddsTotal(OddsTotalV3):
+    """Either has line or alt line id"""
+
+    lineId: NotRequired[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
+            or period["number"] not in periods
+            or "totals" not in period
+        ):
+            continue
+
+        lineId = period["lineId"] if "lineId" in period else None
+        maxTotal = period["maxTotal"] if "maxTotal" in period else None
+
+        for total in period["totals"]:
+            if "altLineId" not in total and lineId is not None:
+                odds_total = cast(OddsTotal, total.copy())
+                odds_total["lineId"] = lineId
+                if maxTotal is not None:
+                    odds_total["max"] = maxTotal
+                result.append(odds_total)
+            else:
+                result.append(cast(OddsTotal, 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,71 @@
+# type: ignore
+import json
+from pathlib import Path
+from typing import Any
+
+from ps3838api import ROOT_DIR
+
+def normalize_to_set(name: str) -> set[str]:
+    return set(
+        name.replace(" II", " 2").replace(" I", "").lower().replace("-", " ").split()
+    )
+
+
+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():
+    # Paths
+    betsapi_path = ROOT_DIR / Path("out/betsapi_leagues.json")
+    ps3838_path = ROOT_DIR / Path("out/ps3838_leagues.json")
+    output_path = ROOT_DIR / Path("out/matched_leagues.json")
+
+    # Load files
+    betsapi_leagues = load_json(betsapi_path)
+    ps3838_data = load_json(ps3838_path)["leagues"]
+
+    # Build normalized index for ps3838
+    ps3838_index = []
+    for league in ps3838_data:
+        ps3838_index.append(
+            {
+                "name": league["name"],
+                "id": league["id"],
+                "norm_set": normalize_to_set(league["name"]),
+            }
+        )
+
+    # Match
+    matched = []
+    for betsapi_league in betsapi_leagues:
+        norm_betsapi = normalize_to_set(betsapi_league)
+        match = next(
+            (
+                {
+                    "betsapi_league": betsapi_league,
+                    "ps3838_league": ps["name"],
+                    "ps3838_id": ps["id"],
+                }
+                for ps in ps3838_index
+                if ps["norm_set"] == norm_betsapi
+            ),
+            {
+                "betsapi_league": betsapi_league,
+                "ps3838_league": None,
+                "ps3838_id": None,
+            },
+        )
+        matched.append(match)
+
+    # 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-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: ps3838api
+Version: 0.1.0
+Summary: Modern PS3838 API
+Author-email: Ilias Dzhabbarov <ilias.dzabbarov@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/iliyasone/ps3838api
+Project-URL: Issues, https://github.com/iliyasone/ps3838api/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: rapidfuzz
+Dynamic: license-file
+
+# Modern PS3838 API
+
+A lightweight Python library to interact with the PS3838 API.
+
+## 🔑 Key Idea
+
+This project aims to keep all method names and behavior as close as possible to the official [PS3838 API documentation](https://ps3838api.github.io/docs/). No abstraction layers that get in your way — just a clean, Pythonic functional interface to the raw API.
+
+If you need assistance, contact me directly on Telegram: [@iliyasone](https://t.me/iliyasone) 💬
+
+## ✨ Features
+
+### `ps3838api.api` — Minimalist, Typed API Wrapper
+
+- **Simple & Clear:** All commonly used endpoints are exposed as straightforward Python functions.
+- **Type-Safe:** Responses are structured using precise `TypedDict` definitions based directly on the official docs.
+- **Clean Data:** Say goodbye to messy, undocumented JSON blobs.
+- **Lightweight:** No bloated ORMs or clunky third-party wrappers — just clean, readable code.
+
+### Event & Odds Matching
+
+- Utility functions like `magic_find_event` and `filter_odds` help you match events and filter odds quickly and effortlessly 🔍.
+
+### Bet Placement
+
+- Place bets with simple functions that eliminate unnecessary overhead. Fast and efficient, just as you like it!
+
+## 🚀 Setup
+
+> You can also check out the [📓 examples.ipynb](https://github.com/iliyasone/ps3838api/blob/release/0.1.0/examples/examples.ipynb) for a quick start!
+
+### 1. Set Environment Variables
+
+Before using the library, set your API credentials via environment variables:
+
+```python
+import os
+
+os.environ["PS3838_LOGIN"] = "your_username"
+os.environ["PS3838_PASSWORD"] = "your_password"
+```
+
+> **Note:** After version 1.0, the library will transition to a client-based API instead of just functions.
+
+---
+
+### 2. Check Client Balance
+
+Quickly check your account balance by calling the API:
+
+```python
+import ps3838api.api as ps
+
+balance = ps.get_client_balance()
+print("Client Balance:", balance)
+```
+
+Expected output:
+
+```json
+{
+    "availableBalance": 200.0,
+    "outstandingTransactions": 0.0,
+    "givenCredit": 0.0,
+    "currency": "USD"
+}
+```
+
+## 🎯 Retrieve Event and Place Bet
+
+Find and use events with ease:
+
+```python
+league = 'Russia - Cup'
+home = 'Lokomotiv Moscow'
+away = 'Akhmat Grozny'
+
+fixtures = ps.get_fixtures()  # sport_id: int = SOCCER_SPORT_ID by default
+```
+
+Match the event using utility functions:
+
+```python
+from ps3838api.matching import magic_find_event
+
+event = magic_find_event(fixtures, league, home, away)
+print(event)
+# Example output: {'eventId': 1607937909, 'leagueId': 2409}
+```
+
+Make sure to validate the event:
+
+```python
+assert isinstance(event, dict)  # also could be Failure
+```
+
+Filter odds for the selected event:
+
+```python
+from ps3838api.logic import filter_odds
+
+odds_response = ps.get_odds()
+odds_eventV3 = filter_odds(odds_response, event_id=event['eventId'])
+```
+
+Select the best total line:
+
+```python
+from ps3838api.totals import get_best_total_line
+
+total_line = get_best_total_line(odds_eventV3)
+print(total_line)
+```
+
+An example response:
+
+```json
+{
+    "points": 4.5,
+    "over": 2.08,
+    "under": 1.775,
+    "lineId": 3058623866,
+    "max": 3750.0
+}
+```
+
+## 💸 Place a Bet
+
+Once you have your event and total line, place your bet:
+
+```python
+assert isinstance(event, dict)  # also could be Failure
+assert total_line is not None 
+
+import ps3838api.api as ps
+
+stake_usdt = 1.0
+
+place_bet_response = ps.place_straigh_bet(
+    stake=stake_usdt,
+    event_id=event['eventId'],
+    bet_type='TOTAL_POINTS',
+    line_id=total_line.get('lineId', None),
+    alt_line_id=total_line.get('altLineId', None),
+    side='OVER',
+    handicap=total_line['points']
+)
+print("Unique Request ID:", place_bet_response['uniqueRequestId'])
+```
+
+You can also check your bet status:
+
+```python
+bets = ps.get_bets(unique_request_ids=[place_bet_response['uniqueRequestId']])
+# Verify the bet status
+```
+
+## ⚠️ Known Issues
+
+- **Logging:** Not implemented yet.
+- **Testing:** Still missing.
+- **CI/CD:** No GitHub CI/CD integration at the moment.
+
+## 🛠️ Local Installation
+
+To install the library locally, run the following commands:
+
+```bash
+git clone https://github.com/iliyasone/ps3838api.git
+cd ps3838api
+pip install . -r dev-requirements.txt
+```
+
+Happy coding

ps3838api-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+ps3838api/__init__.py,sha256=GUa02DNN5yCnNNlKtV9BgBvBknjKDyALU7GaWKLAW9A,113
+ps3838api/api.py,sha256=JEGn3n4ZEqJAPNcruI3lpYOC5C4VOZwfj9ZyoPcql3I,16356
+ps3838api/logic.py,sha256=_6TTV35zTf-m-klj2cfy6LXjAJE7Gji9WVMKmqslzpw,5688
+ps3838api/matching.py,sha256=yCw3N45NMoPlsWGeXVdJ84SQf6me6qGwk-rovnDyHeQ,3664
+ps3838api/tank.py,sha256=-7VVbB9B7oE5Wm8J3ToBjO4wujxRvTUjrg8Evlrbx24,8211
+ps3838api/totals.py,sha256=3t75TDY4xoF8eC6zNpsao_yOXqFESWvzZgsSFNgvifQ,1551
+ps3838api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ps3838api/models/bets.py,sha256=xa2zub-8GbRvVGXguZg3SEy1Kq4a1hUYztHx8ufM12o,6721
+ps3838api/models/errors.py,sha256=VUtqposauK_-t9mW1d6vq986lLyjt-Kj-BupnCn3VIc,918
+ps3838api/models/event.py,sha256=LxW0FXZzxfS_Q8diFcWNGNiN2iZGWcn48xG2CZ9Mvxs,1013
+ps3838api/models/fixtures.py,sha256=5JL5Op8LOGn-tvbLQP65Y0S27fbclRkDnZPNlJZUNbU,1434
+ps3838api/models/lines.py,sha256=6Nh5yxMY00BZV72mvS5yHF2Uasb4-KoOutxX9wqwTkY,615
+ps3838api/models/odds.py,sha256=qHhjcR_glrnka7GrBPvDfwjF9TGGESaHGwH9n5zUYc8,4483
+ps3838api/models/tank.py,sha256=O5JoYaq5FyYrXNELobJQWH5siEnCZHbgT4eHOn5zdI0,96
+ps3838api/utils/match_leagues.py,sha256=vSAMbPDj0sFufIlTTh0PwCLXgcV8hp0eRiGP6FwY-uk,2047
+ps3838api-0.1.0.dist-info/licenses/LICENSE,sha256=7PyWO4q1z3n4SX9uPkti_UH9O1v1p_m7Q6JUSgHr3kg,1073
+ps3838api-0.1.0.dist-info/METADATA,sha256=rrnhV0L4ANBqC7KjMLFqazc2CQ1Y5FWArt0MHB2lMsA,4809
+ps3838api-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ps3838api-0.1.0.dist-info/top_level.txt,sha256=ec8CzKfcDq10-rMF_IM-9kxxxlnT4euiLfVrwQrmO0s,10
+ps3838api-0.1.0.dist-info/RECORD,,

ps3838api-0.1.0.dist-info/WHEEL

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

ps3838api-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2025 Ilias Dzhabbarov
+
+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.
+

ps3838api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ps3838api