review(#135 pass 2): CHANGELOG + async docstring + trim unbounded test

Per second-pass bot review on PR #135:

- CHANGELOG.md [Unreleased]: added Added entry for max_pages kwarg
  + RateLimit export, and Changed entry calling out that *_all() is
  now unbounded by default (was silently capped at 1000 pages).
- _base.py async _list_all docstring: restored the "Raises KalshiError
  on repeated cursor; see sync docstring." note that got trimmed in
  the previous refactor.
- TestMaxPagesNoneIsUnbounded: 1100 → 1010. Still exceeds the old
  1000-cap by enough to prove unboundedness; 90% fewer mock requests.

Skipped:
- nonlocal-vs-dict counter style nit — bot called this take-or-leave;
  the existing pattern is consistent across the test file.

uv run ruff check . clean. uv run pytest
tests/test_base_helpers.py::TestMaxPagesNoneIsUnbounded passes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: TexasCoding

CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to kalshi-sdk will be documented in this file.
 
 ## [Unreleased]
 
+### Added
+
+- **`max_pages: int | None` kwarg on every public `*_all()` method** — sync and
+  async (19 + 19 method signatures). Bounded iteration without manual pagination.
+  `None` (default) iterates until the server returns no cursor; the existing
+  cursor-repeat guard remains the safety net against infinite loops (#98).
+- **`RateLimit` model** exposed via `kalshi.RateLimit` — represents the per-
+  direction token-bucket structure on `AccountApiLimits.read` / `.write`.
+
+### Changed
+
+- **`*_all()` methods are now unbounded by default.** Previously, internal
+  `_list_all` had an invisible 1000-page safety cap that silently truncated
+  callers iterating beyond ~100k items. The cap is gone; the cursor-repeat
+  guard (`KalshiError` on a repeating cursor) provides the runaway protection
+  it always did. Callers who want a cap pass `max_pages=N` explicitly. No
+  user-visible change for anyone iterating <1000 pages (#98).
+
 ### Fixed
 
 - **`/account/limits` response now parses against the live server.** The

kalshi/resources/_base.py

@@ -286,7 +286,10 @@ async def _list_all(
         max_pages: int | None = None,
         cursor_key: str = "cursor",
     ) -> AsyncIterator[T]:
-        """Async counterpart of :meth:`SyncResource._list_all`."""
+        """Async counterpart of :meth:`SyncResource._list_all`.
+
+        Raises ``KalshiError`` on repeated cursor; see sync docstring.
+        """
         current_params = dict(params) if params else {}
         seen_cursors: set[str] = set()
         pages_fetched = 0

tests/test_base_helpers.py

@@ -421,18 +421,20 @@ class TestMaxPagesNoneIsUnbounded:
     def test_sync_iterates_past_1000_pages(
         self, test_auth: KalshiAuth, test_config: KalshiConfig,
     ) -> None:
-        # Page N returns cursor str(N+1) for the first 1100 pages, then empty.
+        # 1010 just exceeds the old 1000 cap — proves the cap is gone without
+        # making the test 100x slower than a normal pagination test.
+        total = 1010
         call_counter = {"n": 0}
 
         def responder(request: httpx.Request) -> httpx.Response:
             call_counter["n"] += 1
             n = call_counter["n"]
-            cursor = str(n) if n < 1100 else ""
+            cursor = str(n) if n < total else ""
             return httpx.Response(
                 200, json={"items": [{"id": f"i{n}"}], "cursor": cursor},
             )
 
         respx.get("https://test.kalshi.com/trade-api/v2/things").mock(side_effect=responder)
         resource = SyncResource(SyncTransport(test_auth, test_config))
         items = list(resource._list_all("/things", _Item, "items"))
-        assert len(items) == 1100, f"Expected 1100 items, got {len(items)} (cap leaked?)"
+        assert len(items) == total, f"Expected {total} items, got {len(items)} (cap leaked?)"