python-ballchasing 0.5.0__tar.gz → 0.5.2__tar.gz

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-ballchasing
-Version: 0.5.0
+Version: 0.5.2
 Summary: A Python wrapper around the Ballchasing API
 Author-email: Rolv-Arild Braaten <rolv_arild@hotmail.com>
 License: MIT License

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/ballchasing/api.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -6,7 +7,8 @@ from pathlib import Path
 from typing import BinaryIO, Iterator
 from urllib.parse import parse_qs, urlparse
 
-from requests import sessions, Response, ConnectionError
+from requests import sessions, Response
+from requests.exceptions import ConnectionError, Timeout
 
 from ballchasing.constants import GroupSortBy, SortDir, AnySeason, AnyRank, AnyReplaySortBy, AnySortDir, \
     AnyVisibility, AnyGroupSortBy, AnyPlayerIdentification, AnyTeamIdentification, AnyMatchResult, NoneOrMore
@@ -16,8 +18,18 @@ from .util.dates import to_rfc3339
 from .util.iterators import deduplicate as deduplicator
 from .util.stats import parse_replay_stats
 
+logger = logging.getLogger("ballchasing")
+
 DEFAULT_URL = "https://ballchasing.com/api"
 
+PATRON_RATE_LIMIT_SLEEP_TIMES = {
+    "regular": 3600 / 1000,
+    "gold": 3600 / 2000,
+    "diamond": 3600 / 5000,
+    "champion": 1 / 8,
+    "gc": 1 / 16,
+}
+
 
 class BallchasingApi:
     """
@@ -48,19 +60,22 @@ class BallchasingApi:
         self.base_url = DEFAULT_URL if base_url is None else base_url
         if do_initial_ping:
             self.ping()
-        if sleep_time_on_rate_limit is None:
-            self.sleep_time_on_rate_limit = {
-                "regular": 3600 / 1000,
-                "gold": 3600 / 2000,
-                "diamond": 3600 / 5000,
-                "champion": 1 / 8,
-                "gc": 1 / 16
-            }.get(self.patron_type or "regular")
-        else:
-            self.sleep_time_on_rate_limit = sleep_time_on_rate_limit
+        self._sleep_time_on_rate_limit = sleep_time_on_rate_limit
         self.print_on_rate_limit = print_on_rate_limit
         self.typed = typed
 
+    @property
+    def sleep_time_on_rate_limit(self) -> float:
+        if self._sleep_time_on_rate_limit is not None:
+            return self._sleep_time_on_rate_limit
+        if self._ping_result is not None:
+            return PATRON_RATE_LIMIT_SLEEP_TIMES.get(self.patron_type or "regular", 3600 / 1000)
+        return PATRON_RATE_LIMIT_SLEEP_TIMES["regular"]
+
+    @sleep_time_on_rate_limit.setter
+    def sleep_time_on_rate_limit(self, value: float | None):
+        self._sleep_time_on_rate_limit = value
+
     @property
     def steam_name(self):
         if self._ping_result is None:
@@ -105,6 +120,7 @@ class BallchasingApi:
         url = f"{self.base_url}{url_or_endpoint}" if url_or_endpoint.startswith("/") else url_or_endpoint
         max_retries = 8
         retries = 0
+        rate_limit_retries = 0
         while True:
             try:
                 r: Response = self._session.request(method=method, url=url, headers=headers, **params)
@@ -113,22 +129,29 @@ class BallchasingApi:
                 elif r.status_code == 429:
                     self.rate_limit_count += 1
                     if self.print_on_rate_limit:
-                        print(f"Rate limited at {url} ({self.rate_limit_count} total rate limits)")
+                        logger.warning(f"Rate limited at {url} ({self.rate_limit_count} total rate limits)")
+                    else:
+                        logger.debug(f"Rate limited at {url} ({self.rate_limit_count} total rate limits)")
+                    rate_limit_retries += 1
+                    if rate_limit_retries > max_retries:
+                        r.raise_for_status()
                     retry_after = r.headers.get("Retry-After", '0')
                     retry_after = int(retry_after) if retry_after.isdigit() else None
                     if retry_after:  # integer > 0
                         time.sleep(retry_after)
                     elif self.sleep_time_on_rate_limit:
                         time.sleep(self.sleep_time_on_rate_limit)
-                elif r.status_code == 504:
-                    raise ConnectionError("Gateway Timeout. The server did not respond in time.")
+                    else:
+                        time.sleep(max(1.0, float(2 ** (rate_limit_retries - 1))))
+                elif r.status_code in (502, 503, 504):
+                    raise ConnectionError(f"Server error {r.status_code}: {r.reason or 'Transient gateway error'}")
                 else:
-                    r.raise_for_status()  # Raise an error for any other status code'
-            except ConnectionError as e:
+                    r.raise_for_status()  # Raise an error for any other status code
+            except (ConnectionError, Timeout) as e:
                 if retries >= max_retries - 1:
                     raise e
                 s = 2 ** retries
-                print(f"Connection error, trying again in {s} seconds...")
+                logger.warning(f"Connection or timeout error ({e}), trying again in {s} seconds...")
                 time.sleep(s)
                 retries += 1
 
@@ -153,7 +176,9 @@ class BallchasingApi:
         # consumer processing items.  When prefetch=False (e.g. deep mode
         # where the consumer also makes API calls), the next request is
         # submitted *after* yielding to avoid doubling the request rate.
-        remaining = params["count"]
+        remaining = params.get("count", 0)
+        if remaining <= 0:
+            return
 
         def fetch_page(p):
             return self._request(url, "GET", params=p).json()
@@ -164,15 +189,19 @@ class BallchasingApi:
 
             while remaining > 0:
                 d = future.result()
-                batch = d["list"][:min(remaining, 200)]
+                batch = d.get("list", [])[:min(remaining, 200)]
                 remaining -= len(batch)
 
-                has_next = "next" in d and remaining > 0
+                next_url = d.get("next")
+                has_next = bool(next_url) and remaining > 0
                 if has_next:
-                    next_url = d["next"]
-                    params["after"] = parse_qs(urlparse(next_url).query)["after"][0]
+                    after_param = parse_qs(urlparse(next_url).query).get("after", [None])[0]
+                    if after_param is not None:
+                        params["after"] = after_param
+                    else:
+                        has_next = False
                     params["count"] = min(remaining, 200)
-                    if prefetch:
+                    if prefetch and has_next:
                         future = executor.submit(fetch_page, dict(params))
 
                 yield from batch
@@ -207,6 +236,7 @@ class BallchasingApi:
             deep: bool = False,
             typed: bool | None = None,
             deduplicate: bool = False,
+            disable_prefetch: bool | None = None,
     ) -> Iterator[dict | ShallowReplay | DeepReplay]:
         """
         This endpoint lets you filter and retrieve replays. The implementation returns an iterator.
@@ -242,6 +272,7 @@ class BallchasingApi:
         :param deep: whether to get full stats for each replay (will be much slower).
         :param typed: whether to return a typed object (default is self.typed).
         :param deduplicate: whether to deduplicate replays that seem to be the same game.
+        :param disable_prefetch: whether to disable prefetching replays.
         :return: an iterator over the replays returned by the API.
         """
         url = f"{self.base_url}/replays"
@@ -256,12 +287,15 @@ class BallchasingApi:
         if typed is None:
             typed = self.typed
 
-        iterator = self._iterable_from_request(url, params, prefetch=not deep)
-        if deep:
-            iterator = (self.get_replay(r["id"]) for r in iterator)
+        if disable_prefetch is None:
+            disable_prefetch = deep
+
+        iterator = self._iterable_from_request(url, params, prefetch=not disable_prefetch)
         if deduplicate:
             # Deep replays have match and replay IDs to deduplicate with. For shallow replays we check dates.
             iterator = deduplicator(iterator, check_dates=not deep)
+        if deep:
+            iterator = (self.get_replay(r["id"]) for r in iterator)
         if typed:
             if deep:
                 iterator = (DeepReplay(**r) for r in iterator)
@@ -336,6 +370,7 @@ class BallchasingApi:
             sort_dir: AnySortDir = SortDir.DESCENDING,
             deep: bool = False,
             typed: bool | None = None,
+            disable_prefetch: bool | None = None,
     ) -> Iterator[dict | ShallowGroup | DeepGroup]:
         """
         This endpoint lets you filter and retrieve replay groups.
@@ -354,12 +389,17 @@ class BallchasingApi:
         :param sort_dir: Sort direction.
         :param deep: whether to get full stats for each group (will be much slower).
         :param typed: whether to return a typed object (default is self.typed).
+        :param disable_prefetch: whether to disable prefetching.
         :return: an iterator over the groups returned by the API.
         """
         url = f"{self.base_url}/groups/"
         params = {"name": name, "creator": creator, "group": group, "created-before": to_rfc3339(created_before),
                   "created-after": to_rfc3339(created_after), "count": count, "sort-by": sort_by, "sort-dir": sort_dir}
-        iterator = self._iterable_from_request(url, params, prefetch=not deep)
+
+        if disable_prefetch is None:
+            disable_prefetch = deep
+
+        iterator = self._iterable_from_request(url, params, prefetch=not disable_prefetch)
         if typed is None:
             typed = self.typed
         if deep:

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/ballchasing/typed/shared.py

@@ -20,13 +20,14 @@ class _BaseModel:
             value = getattr(self, field.name)
             if isinstance(value, _BaseModel):
                 result[field.name] = value.to_dict()
-            elif isinstance(value, list) and len(value) > 0:
-                result[field.name] = [item.to_dict() if isinstance(item, _BaseModel) else item for item in value]
+            elif isinstance(value, list):
+                if len(value) > 0:
+                    result[field.name] = [item.to_dict() if isinstance(item, _BaseModel) else item for item in value]
             elif isinstance(value, datetime):
                 # Convert datetime objects to rfc3339 formatted strings
                 result[field.name] = to_rfc3339(value)
-            elif bool(value):
-                # Only include non-empty values, to match the API's behavior
+            elif value is not None:
+                # Include non-None values, preserving valid 0 and False values
                 result[field.name] = value
         return result
 
@@ -151,7 +152,7 @@ class BasePlayer(_BaseModel, _DictToTypeMixin):
         return NotImplemented
 
     def is_bot(self):
-        return self.id.id == "" and self.id.platform == ""
+        return self.id is None or (self.id.id == "" and self.id.platform == "")
 
 
 @dataclass

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/ballchasing/util/replays.py

@@ -77,7 +77,7 @@ def is_standard_replay(replay, allow_bots=False, allow_splitscreen=False) -> tup
     if map_id is None or map_id not in Map.STANDARD_MAPS + (Map.NEOTOKYO_TOON_P,):
         if playlist_id.startswith("ranked"):
             logging.warning("Replay %s has non-standard map %s in ranked playlist %s",
-                            replay["id"], map_id, playlist_id)
+                            replay.get("id", "<unknown>"), map_id, playlist_id)
         return False, f"Map is not standard: {map_id}"
     if map_id in (Map.PARK_SNOWY_P, Map.UTOPIASTADIUM_SNOW_P, Map.EUROSTADIUM_SNOWNIGHT_P):
         if playlist_id not in Playlist.RANKED:
@@ -128,7 +128,7 @@ def is_standard_replay(replay, allow_bots=False, allow_splitscreen=False) -> tup
         if not pid and not allow_bots:
             return False, f"Player {name} has no ID"
         # Split screen players get a "player_number" that is not 0
-        player_number = pid.get("player_number", 0)
+        player_number = (pid or {}).get("player_number", 0)
         if player_number != 0 and not allow_splitscreen:
             return False, f"Player {name} has player number {player_number}, indicating split-screen"
 

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-ballchasing"
-version = "0.5.0"
+version = "0.5.2"
 authors = [
     { name = "Rolv-Arild Braaten", email = "rolv_arild@hotmail.com" },
 ]
@@ -29,4 +29,4 @@ dependencies = [
 where = ["."]
 
 [tool.setuptools.package-data]
-ballchasing = ["*.tsv"]
+ballchasing = ["*.tsv"]

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/python_ballchasing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-ballchasing
-Version: 0.5.0
+Version: 0.5.2
 Summary: A Python wrapper around the Ballchasing API
 Author-email: Rolv-Arild Braaten <rolv_arild@hotmail.com>
 License: MIT License

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/python_ballchasing.egg-info/SOURCES.txt

@@ -24,4 +24,5 @@ python_ballchasing.egg-info/top_level.txt
 scripts/get_maps.py
 scripts/make_types.py
 scripts/test.py
-scripts/test_typed.py
+scripts/test_typed.py
+tests/test_fixes.py

{python_ballchasing-0.5.0 → python_ballchasing-0.5.2}/python_ballchasing.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 ballchasing
 dist
 scripts
+tests

python_ballchasing-0.5.2/tests/test_fixes.py

@@ -0,0 +1,246 @@
+import logging
+from unittest.mock import patch, MagicMock
+import pytest
+from requests import Response
+from requests.exceptions import ConnectionError as RequestsConnectionError, Timeout
+
+from ballchasing.api import BallchasingApi, PATRON_RATE_LIMIT_SLEEP_TIMES
+from ballchasing.constants import Map
+from ballchasing.typed.shared import PlayerID, BasePlayer, BaseReplay
+from ballchasing.typed.deep_replay import DeepReplay, TeamCoreStatsDR, PlayerCoreStatsDR
+from ballchasing.util.replays import is_standard_replay
+
+
+def make_mock_response(status_code=200, json_data=None, headers=None):
+    resp = Response()
+    resp.status_code = status_code
+    if json_data is not None:
+        resp._content = (
+            bytes(__import__("json").dumps(json_data), "utf-8")
+        )
+    else:
+        resp._content = b"{}"
+    if headers:
+        resp.headers.update(headers)
+    return resp
+
+
+class TestInitialPingBypass:
+    def test_do_initial_ping_false_makes_no_requests(self):
+        with patch.object(BallchasingApi, "_request") as mock_request:
+            api = BallchasingApi("dummy_key", do_initial_ping=False)
+            mock_request.assert_not_called()
+            assert api._ping_result is None
+
+    def test_sleep_time_on_rate_limit_defaults_to_regular_when_not_pinged(self):
+        with patch.object(BallchasingApi, "_request") as mock_request:
+            api = BallchasingApi("dummy_key", do_initial_ping=False)
+            assert api.sleep_time_on_rate_limit == PATRON_RATE_LIMIT_SLEEP_TIMES["regular"]
+            mock_request.assert_not_called()
+
+    def test_sleep_time_on_rate_limit_explicit(self):
+        api = BallchasingApi("dummy_key", sleep_time_on_rate_limit=1.5, do_initial_ping=False)
+        assert api.sleep_time_on_rate_limit == 1.5
+
+    def test_sleep_time_updates_after_ping(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        assert api.sleep_time_on_rate_limit == PATRON_RATE_LIMIT_SLEEP_TIMES["regular"]
+
+        # Simulate ping result later
+        api._ping_result = {"type": "gold", "name": "TestUser"}
+        assert api.sleep_time_on_rate_limit == PATRON_RATE_LIMIT_SLEEP_TIMES["gold"]
+
+
+class TestHttpRetryAndLogging:
+    @pytest.mark.parametrize("status_code", [502, 503, 504])
+    def test_retry_transient_gateway_errors(self, status_code):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        err_resp = make_mock_response(status_code=status_code)
+        ok_resp = make_mock_response(status_code=200, json_data={"success": True})
+
+        with patch.object(api._session, "request", side_effect=[err_resp, ok_resp]) as mock_req, \
+             patch("time.sleep") as mock_sleep:
+            res = api._request("/test", "GET")
+            assert res.status_code == 200
+            assert mock_req.call_count == 2
+            mock_sleep.assert_called_once_with(1)  # 2 ** 0
+
+    def test_retry_timeout(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        ok_resp = make_mock_response(status_code=200, json_data={"success": True})
+
+        with patch.object(api._session, "request", side_effect=[Timeout("timed out"), ok_resp]) as mock_req, \
+             patch("time.sleep") as mock_sleep:
+            res = api._request("/test", "GET")
+            assert res.status_code == 200
+            assert mock_req.call_count == 2
+            mock_sleep.assert_called_once_with(1)
+
+    def test_retry_exhaustion_raises(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        err_resp = make_mock_response(status_code=502)
+
+        with patch.object(api._session, "request", return_value=err_resp), \
+             patch("time.sleep"):
+            with pytest.raises(RequestsConnectionError):
+                api._request("/test", "GET")
+
+    def test_rate_limit_backoff_retry_after(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        rl_resp = make_mock_response(status_code=429, headers={"Retry-After": "3"})
+        ok_resp = make_mock_response(status_code=200, json_data={"ok": True})
+
+        with patch.object(api._session, "request", side_effect=[rl_resp, ok_resp]), \
+             patch("time.sleep") as mock_sleep:
+            res = api._request("/test", "GET")
+            assert res.status_code == 200
+            mock_sleep.assert_called_once_with(3)
+
+    def test_rate_limit_backoff_default_when_unset(self):
+        api = BallchasingApi("dummy_key", sleep_time_on_rate_limit=0, do_initial_ping=False)
+        rl_resp = make_mock_response(status_code=429)
+        ok_resp = make_mock_response(status_code=200, json_data={"ok": True})
+
+        with patch.object(api._session, "request", side_effect=[rl_resp, ok_resp]), \
+             patch("time.sleep") as mock_sleep:
+            res = api._request("/test", "GET")
+            assert res.status_code == 200
+            assert mock_sleep.call_count == 1
+            assert mock_sleep.call_args[0][0] >= 1.0
+
+    def test_logging_used_on_retry(self, caplog):
+        api = BallchasingApi("dummy_key", do_initial_ping=False, print_on_rate_limit=True)
+        rl_resp = make_mock_response(status_code=429)
+        ok_resp = make_mock_response(status_code=200, json_data={"ok": True})
+
+        with caplog.at_level(logging.WARNING, logger="ballchasing"), \
+             patch.object(api._session, "request", side_effect=[rl_resp, ok_resp]), \
+             patch("time.sleep"):
+            api._request("/test", "GET")
+            assert any("Rate limited" in record.message for record in caplog.records)
+
+
+class TestDeduplicationBeforeDeepFetch:
+    def test_get_replays_deduplicates_before_deep_call(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        replays_batch = [
+            {"id": "rep1", "rocket_league_id": "rl1"},
+            {"id": "rep1", "rocket_league_id": "rl1"},  # duplicate id
+            {"id": "rep2", "rocket_league_id": "rl2"},
+        ]
+
+        def fake_iterable(*args, **kwargs):
+            yield from replays_batch
+
+        with patch.object(api, "_iterable_from_request", side_effect=fake_iterable), \
+             patch.object(api, "get_replay", side_effect=lambda rid: {"id": rid, "deep": True}) as mock_get_replay:
+            results = list(api.get_replays(deep=True, deduplicate=True))
+            assert len(results) == 2
+            assert [r["id"] for r in results] == ["rep1", "rep2"]
+            # get_replay should only have been called twice (for rep1 and rep2), NOT 3 times
+            assert mock_get_replay.call_count == 2
+            mock_get_replay.assert_any_call("rep1")
+            mock_get_replay.assert_any_call("rep2")
+
+
+class TestCountZeroIterable:
+    def test_count_zero_makes_no_requests(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        with patch.object(api, "_request") as mock_req:
+            replays = list(api.get_replays(count=0))
+            assert replays == []
+            mock_req.assert_not_called()
+
+            groups = list(api.get_groups(count=0))
+            assert groups == []
+            mock_req.assert_not_called()
+
+    def test_next_url_missing_after_param_handled_defensively(self):
+        api = BallchasingApi("dummy_key", do_initial_ping=False)
+        # First page has 'next' without 'after' query param
+        page1 = {"list": [{"id": "r1"}], "next": "https://ballchasing.com/api/replays?other=val"}
+
+        with patch.object(api, "_request") as mock_req:
+            mock_req.return_value = make_mock_response(200, json_data=page1)
+            replays = list(api.get_replays(count=10, disable_prefetch=True))
+            assert len(replays) == 1
+            assert replays[0]["id"] == "r1"
+
+
+class TestToDictPreservesFalsyValues:
+    def test_preserves_zero_and_false(self):
+        pid = PlayerID(platform="steam", id="12345", player_number=0)
+        d = pid.to_dict()
+        assert d["player_number"] == 0
+        assert d["id"] == "12345"
+        assert d["platform"] == "steam"
+
+        player = BasePlayer(name="Test", id=pid, pro=False, mvp=False)
+        pd = player.to_dict()
+        assert pd["pro"] is False
+        assert pd["mvp"] is False
+
+        core = PlayerCoreStatsDR(goals=0, assists=0, saves=0, score=0, mvp=False)
+        cd = core.to_dict()
+        assert cd["goals"] == 0
+        assert cd["assists"] == 0
+        assert cd["saves"] == 0
+        assert cd["score"] == 0
+        assert cd["mvp"] is False
+
+        replay = BaseReplay(duration=300, overtime=False, overtime_seconds=0)
+        rd = replay.to_dict()
+        assert rd["overtime"] is False
+        assert rd["overtime_seconds"] == 0
+        assert rd["duration"] == 300
+
+    def test_drops_none(self):
+        player = BasePlayer(name="Test", rank=None)
+        pd = player.to_dict()
+        assert "rank" not in pd
+
+
+class TestNonePlayerIdFixes:
+    def test_base_player_is_bot_with_none_id(self):
+        player = BasePlayer(name="BotPlayer", id=None)
+        assert player.is_bot() is True
+
+    def test_base_player_is_bot_with_empty_id(self):
+        player = BasePlayer(name="BotPlayer", id=PlayerID(platform="", id=""))
+        assert player.is_bot() is True
+
+    def test_base_player_is_not_bot(self):
+        player = BasePlayer(name="Human", id=PlayerID(platform="steam", id="123"))
+        assert player.is_bot() is False
+
+    def test_is_standard_replay_with_none_player_id(self):
+        # Construct a replay where a player has id: None
+        replay = {
+            "id": "rep123",
+            "playlist_id": "ranked-doubles",
+            "map_code": Map.STADIUM_P,
+            "duration": 300,
+            "blue": {
+                "goals": 2,
+                "players": [
+                    {"name": "P1", "start_time": 0, "end_time": 300, "id": {"platform": "steam", "id": "1", "player_number": 0}},
+                    {"name": "Bot1", "start_time": 0, "end_time": 300, "id": None},
+                ]
+            },
+            "orange": {
+                "goals": 1,
+                "players": [
+                    {"name": "P2", "start_time": 0, "end_time": 300, "id": {"platform": "steam", "id": "2", "player_number": 0}},
+                    {"name": "P3", "start_time": 0, "end_time": 300, "id": {"platform": "steam", "id": "3", "player_number": 0}},
+                ]
+            }
+        }
+        # With allow_bots=True, should not crash with AttributeError and should be valid
+        valid, reason = is_standard_replay(replay, allow_bots=True)
+        assert valid is True
+        assert reason == "No issues found"
+
+        # With allow_bots=False, should return False because Bot1 has no ID, without crashing
+        valid_nobots, reason_nobots = is_standard_replay(replay, allow_bots=False)
+        assert valid_nobots is False
+        assert "Bot1 has no ID" in reason_nobots