crashbytes-apiclient 1.0.0__tar.gz

crashbytes_apiclient-1.0.0/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @CrashBytes

crashbytes_apiclient-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check src/ tests/
+      - run: mypy --strict src/
+      - run: pytest --cov=crashbytes_apiclient --cov-branch --cov-fail-under=90

crashbytes_apiclient-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

crashbytes_apiclient-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+dist/
+build/
+*.egg-info/
+.coverage
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+

crashbytes_apiclient-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CrashBytes
+
+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.

crashbytes_apiclient-1.0.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: crashbytes-apiclient
+Version: 1.0.0
+Summary: httpx API client toolkit — pagination, retry, rate limiting, auth refresh, middleware.
+Project-URL: Homepage, https://github.com/CrashBytes/crashbytes-apiclient
+Project-URL: Repository, https://github.com/CrashBytes/crashbytes-apiclient
+Project-URL: Issues, https://github.com/CrashBytes/crashbytes-apiclient/issues
+Author-email: CrashBytes <crashbytes@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api-client,httpx,middleware,pagination,retry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-httpx; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# crashbytes-apiclient
+
+httpx API client toolkit — pagination, retry, rate limiting, auth refresh, middleware.
+
+## Install
+
+```bash
+pip install crashbytes-apiclient
+```
+
+## Usage
+
+```python
+from crashbytes_apiclient import (
+    ApiClient, BearerAuth, RetryMiddleware, CursorPaginator,
+)
+
+client = ApiClient(
+    base_url="https://api.example.com",
+    auth=BearerAuth("your-token"),
+    middlewares=[RetryMiddleware(max_retries=3)],
+)
+
+# Simple requests
+response = client.get("/users")
+response = client.post("/users", json={"name": "Alice"})
+
+# Paginated iteration
+for batch in client.paginate("/items", CursorPaginator()):
+    for item in batch:
+        process(item)
+
+client.close()
+```
+
+## Features
+
+- **Auth:** `BearerAuth`, `RefreshableAuth` (auto-refresh on 401)
+- **Middleware:** `RetryMiddleware`, `RateLimitMiddleware`, custom middleware protocol
+- **Pagination:** `CursorPaginator`, `PageNumberPaginator`
+- **HTTP Methods:** `.get()`, `.post()`, `.put()`, `.patch()`, `.delete()`
+- **Context Manager:** `with ApiClient(...) as client:`
+
+## License
+
+MIT

crashbytes_apiclient-1.0.0/README.md

@@ -0,0 +1,46 @@
+# crashbytes-apiclient
+
+httpx API client toolkit — pagination, retry, rate limiting, auth refresh, middleware.
+
+## Install
+
+```bash
+pip install crashbytes-apiclient
+```
+
+## Usage
+
+```python
+from crashbytes_apiclient import (
+    ApiClient, BearerAuth, RetryMiddleware, CursorPaginator,
+)
+
+client = ApiClient(
+    base_url="https://api.example.com",
+    auth=BearerAuth("your-token"),
+    middlewares=[RetryMiddleware(max_retries=3)],
+)
+
+# Simple requests
+response = client.get("/users")
+response = client.post("/users", json={"name": "Alice"})
+
+# Paginated iteration
+for batch in client.paginate("/items", CursorPaginator()):
+    for item in batch:
+        process(item)
+
+client.close()
+```
+
+## Features
+
+- **Auth:** `BearerAuth`, `RefreshableAuth` (auto-refresh on 401)
+- **Middleware:** `RetryMiddleware`, `RateLimitMiddleware`, custom middleware protocol
+- **Pagination:** `CursorPaginator`, `PageNumberPaginator`
+- **HTTP Methods:** `.get()`, `.post()`, `.put()`, `.patch()`, `.delete()`
+- **Context Manager:** `with ApiClient(...) as client:`
+
+## License
+
+MIT

crashbytes_apiclient-1.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "crashbytes-apiclient"
+version = "1.0.0"
+description = "httpx API client toolkit — pagination, retry, rate limiting, auth refresh, middleware."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.27"]
+authors = [{ name = "CrashBytes", email = "crashbytes@users.noreply.github.com" }]
+keywords = ["httpx", "api-client", "pagination", "retry", "middleware"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov", "pytest-asyncio", "pytest-httpx", "mypy", "ruff"]
+
+[project.urls]
+Homepage = "https://github.com/CrashBytes/crashbytes-apiclient"
+Repository = "https://github.com/CrashBytes/crashbytes-apiclient"
+Issues = "https://github.com/CrashBytes/crashbytes-apiclient/issues"
+
+[tool.ruff]
+target-version = "py310"
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM", "TCH"]
+
+[tool.mypy]
+strict = true
+python_version = "3.10"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+branch = true
+source = ["crashbytes_apiclient"]
+
+[tool.coverage.report]
+fail_under = 90

crashbytes_apiclient-1.0.0/src/crashbytes_apiclient/__init__.py

@@ -0,0 +1,21 @@
+"""crashbytes-apiclient — httpx API client toolkit."""
+
+from crashbytes_apiclient._core import (
+    ApiClient,
+    BearerAuth,
+    CursorPaginator,
+    PageNumberPaginator,
+    RateLimitMiddleware,
+    RefreshableAuth,
+    RetryMiddleware,
+)
+
+__all__ = [
+    "ApiClient",
+    "BearerAuth",
+    "CursorPaginator",
+    "PageNumberPaginator",
+    "RateLimitMiddleware",
+    "RefreshableAuth",
+    "RetryMiddleware",
+]

crashbytes_apiclient-1.0.0/src/crashbytes_apiclient/_core.py

@@ -0,0 +1,280 @@
+"""httpx API client toolkit — pagination, retry, rate limiting, auth, middleware."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any, Protocol
+
+import httpx
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Iterator
+
+
+# ── Auth ────────────────────────────────────────────────────────────
+
+
+class BearerAuth(httpx.Auth):
+    """Static bearer token authentication."""
+
+    def __init__(self, token: str) -> None:
+        self._token = token
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        request.headers["Authorization"] = f"Bearer {self._token}"
+        yield request
+
+
+class RefreshableAuth(httpx.Auth):
+    """Bearer auth that refreshes the token when it expires."""
+
+    def __init__(
+        self,
+        token: str,
+        refresh_fn: Any,
+        refresh_status: int = 401,
+    ) -> None:
+        self._token = token
+        self._refresh_fn = refresh_fn
+        self._refresh_status = refresh_status
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        request.headers["Authorization"] = f"Bearer {self._token}"
+        response = yield request
+        if response.status_code == self._refresh_status:
+            self._token = self._refresh_fn()
+            request.headers["Authorization"] = f"Bearer {self._token}"
+            yield request
+
+
+# ── Middleware Protocol ─────────────────────────────────────────────
+
+
+class Middleware(Protocol):
+    """Protocol for request/response middleware."""
+
+    def process_request(self, request: httpx.Request) -> httpx.Request:
+        """Process the request before sending."""
+        ...
+
+    def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Process the response after receiving."""
+        ...
+
+
+class RetryMiddleware:
+    """Retry failed requests with exponential backoff."""
+
+    def __init__(
+        self,
+        max_retries: int = 3,
+        retry_statuses: tuple[int, ...] = (429, 500, 502, 503, 504),
+        delay: float = 0.5,
+        backoff: float = 2.0,
+    ) -> None:
+        self.max_retries = max_retries
+        self.retry_statuses = retry_statuses
+        self.delay = delay
+        self.backoff = backoff
+
+    def process_request(self, request: httpx.Request) -> httpx.Request:
+        return request
+
+    def process_response(self, response: httpx.Response) -> httpx.Response:
+        return response
+
+    def should_retry(self, response: httpx.Response) -> bool:
+        """Check if the response should trigger a retry."""
+        return response.status_code in self.retry_statuses
+
+
+class RateLimitMiddleware:
+    """Simple rate limiting between requests."""
+
+    def __init__(self, min_interval: float = 0.1) -> None:
+        self._min_interval = min_interval
+        self._last_request_time = 0.0
+
+    def process_request(self, request: httpx.Request) -> httpx.Request:
+        elapsed = time.monotonic() - self._last_request_time
+        if elapsed < self._min_interval:
+            time.sleep(self._min_interval - elapsed)
+        self._last_request_time = time.monotonic()
+        return request
+
+    def process_response(self, response: httpx.Response) -> httpx.Response:
+        return response
+
+
+# ── Paginator Protocols ─────────────────────────────────────────────
+
+
+class CursorPaginator:
+    """Extract next-page cursor from response JSON."""
+
+    def __init__(
+        self,
+        cursor_param: str = "cursor",
+        cursor_path: str = "next_cursor",
+        results_path: str = "results",
+    ) -> None:
+        self._cursor_param = cursor_param
+        self._cursor_path = cursor_path
+        self._results_path = results_path
+
+    def get_results(self, data: dict[str, Any]) -> list[Any]:
+        """Extract results from the response data."""
+        return data.get(self._results_path, [])  # type: ignore[no-any-return]
+
+    def get_next_params(self, data: dict[str, Any]) -> dict[str, str] | None:
+        """Get params for the next page, or None if done."""
+        cursor = data.get(self._cursor_path)
+        if cursor:
+            return {self._cursor_param: str(cursor)}
+        return None
+
+
+class PageNumberPaginator:
+    """Page-number-based pagination."""
+
+    def __init__(
+        self,
+        page_param: str = "page",
+        results_path: str = "results",
+        total_path: str = "total_pages",
+    ) -> None:
+        self._page_param = page_param
+        self._results_path = results_path
+        self._total_path = total_path
+        self._current_page = 1
+
+    def get_results(self, data: dict[str, Any]) -> list[Any]:
+        """Extract results from the response data."""
+        return data.get(self._results_path, [])  # type: ignore[no-any-return]
+
+    def get_next_params(self, data: dict[str, Any]) -> dict[str, str] | None:
+        """Get params for the next page, or None if done."""
+        total = data.get(self._total_path, 0)
+        if self._current_page < int(total):
+            self._current_page += 1
+            return {self._page_param: str(self._current_page)}
+        return None
+
+
+# ── API Client ──────────────────────────────────────────────────────
+
+
+class ApiClient:
+    """High-level httpx API client with middleware and pagination."""
+
+    def __init__(
+        self,
+        base_url: str,
+        auth: httpx.Auth | None = None,
+        middlewares: list[Any] | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._auth = auth
+        self._middlewares = middlewares or []
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            auth=auth,
+            headers=headers or {},
+            timeout=timeout,
+        )
+
+    def _apply_request_middleware(self, request: httpx.Request) -> httpx.Request:
+        for mw in self._middlewares:
+            request = mw.process_request(request)
+        return request
+
+    def _apply_response_middleware(self, response: httpx.Response) -> httpx.Response:
+        for mw in self._middlewares:
+            response = mw.process_response(response)
+        return response
+
+    def _send_with_retry(self, request: httpx.Request) -> httpx.Response:
+        retry_mw = None
+        for mw in self._middlewares:
+            if isinstance(mw, RetryMiddleware):
+                retry_mw = mw
+                break
+
+        if retry_mw is None:
+            return self._client.send(request)
+
+        delay = retry_mw.delay
+        last_response: httpx.Response | None = None
+        for attempt in range(retry_mw.max_retries + 1):
+            response = self._client.send(request)
+            last_response = response
+            if not retry_mw.should_retry(response):
+                return response
+            if attempt < retry_mw.max_retries:
+                time.sleep(delay)
+                delay *= retry_mw.backoff
+        assert last_response is not None
+        return last_response
+
+    def request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        """Send an HTTP request."""
+        request = self._client.build_request(method, path, **kwargs)
+        request = self._apply_request_middleware(request)
+        response = self._send_with_retry(request)
+        return self._apply_response_middleware(response)
+
+    def get(self, path: str, **kwargs: Any) -> httpx.Response:
+        """Send a GET request."""
+        return self.request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> httpx.Response:
+        """Send a POST request."""
+        return self.request("POST", path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> httpx.Response:
+        """Send a PUT request."""
+        return self.request("PUT", path, **kwargs)
+
+    def patch(self, path: str, **kwargs: Any) -> httpx.Response:
+        """Send a PATCH request."""
+        return self.request("PATCH", path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> httpx.Response:
+        """Send a DELETE request."""
+        return self.request("DELETE", path, **kwargs)
+
+    def paginate(
+        self,
+        path: str,
+        paginator: CursorPaginator | PageNumberPaginator,
+        **kwargs: Any,
+    ) -> Iterator[list[Any]]:
+        """Iterate through paginated results."""
+        params: dict[str, str] = dict(kwargs.pop("params", {}))
+        while True:
+            response = self.get(path, params=params, **kwargs)
+            response.raise_for_status()
+            data = response.json()
+            results = paginator.get_results(data)
+            if results:
+                yield results
+            next_params = paginator.get_next_params(data)
+            if next_params is None:
+                break
+            params.update(next_params)
+
+    def close(self) -> None:
+        """Close the underlying httpx client."""
+        self._client.close()
+
+    def __enter__(self) -> ApiClient:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

crashbytes_apiclient-1.0.0/tests/test_apiclient.py

@@ -0,0 +1,315 @@
+"""Tests for crashbytes-apiclient."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import httpx
+
+from crashbytes_apiclient import (
+    ApiClient,
+    BearerAuth,
+    CursorPaginator,
+    PageNumberPaginator,
+    RateLimitMiddleware,
+    RefreshableAuth,
+    RetryMiddleware,
+)
+
+# ── Auth Tests ──────────────────────────────────────────────────────
+
+
+class TestBearerAuth:
+    def test_adds_header(self) -> None:
+        auth = BearerAuth("mytoken")
+        request = httpx.Request("GET", "https://example.com")
+        flow = auth.auth_flow(request)
+        modified = next(flow)
+        assert modified.headers["Authorization"] == "Bearer mytoken"
+
+
+class TestRefreshableAuth:
+    def test_no_refresh_on_success(self) -> None:
+        auth = RefreshableAuth("token1", lambda: "token2")
+        request = httpx.Request("GET", "https://example.com")
+        flow = auth.auth_flow(request)
+        modified = next(flow)
+        assert modified.headers["Authorization"] == "Bearer token1"
+
+    def test_refresh_on_401(self) -> None:
+        refresh_fn = MagicMock(return_value="token2")
+        auth = RefreshableAuth("token1", refresh_fn)
+        request = httpx.Request("GET", "https://example.com")
+        flow = auth.auth_flow(request)
+        modified = next(flow)
+        assert modified.headers["Authorization"] == "Bearer token1"
+
+        # Simulate 401 response
+        response = httpx.Response(401, request=request)
+        modified = flow.send(response)
+        assert modified.headers["Authorization"] == "Bearer token2"
+        refresh_fn.assert_called_once()
+
+
+# ── Middleware Tests ────────────────────────────────────────────────
+
+
+class TestRetryMiddleware:
+    def test_should_retry_on_503(self) -> None:
+        mw = RetryMiddleware()
+        response = httpx.Response(503)
+        assert mw.should_retry(response) is True
+
+    def test_should_not_retry_on_200(self) -> None:
+        mw = RetryMiddleware()
+        response = httpx.Response(200)
+        assert mw.should_retry(response) is False
+
+    def test_process_request_passthrough(self) -> None:
+        mw = RetryMiddleware()
+        request = httpx.Request("GET", "https://example.com")
+        assert mw.process_request(request) is request
+
+    def test_process_response_passthrough(self) -> None:
+        mw = RetryMiddleware()
+        response = httpx.Response(200)
+        assert mw.process_response(response) is response
+
+
+class TestRateLimitMiddleware:
+    def test_process_request(self) -> None:
+        mw = RateLimitMiddleware(min_interval=0.0)
+        request = httpx.Request("GET", "https://example.com")
+        result = mw.process_request(request)
+        assert result is request
+
+    def test_process_response_passthrough(self) -> None:
+        mw = RateLimitMiddleware()
+        response = httpx.Response(200)
+        assert mw.process_response(response) is response
+
+
+# ── Paginator Tests ─────────────────────────────────────────────────
+
+
+class TestCursorPaginator:
+    def test_get_results(self) -> None:
+        pag = CursorPaginator()
+        data: dict[str, Any] = {"results": [1, 2, 3], "next_cursor": "abc"}
+        assert pag.get_results(data) == [1, 2, 3]
+
+    def test_get_next_params(self) -> None:
+        pag = CursorPaginator()
+        data: dict[str, Any] = {"results": [], "next_cursor": "abc"}
+        assert pag.get_next_params(data) == {"cursor": "abc"}
+
+    def test_get_next_params_none(self) -> None:
+        pag = CursorPaginator()
+        data: dict[str, Any] = {"results": [], "next_cursor": None}
+        assert pag.get_next_params(data) is None
+
+    def test_get_next_params_missing(self) -> None:
+        pag = CursorPaginator()
+        data: dict[str, Any] = {"results": []}
+        assert pag.get_next_params(data) is None
+
+    def test_custom_keys(self) -> None:
+        pag = CursorPaginator(
+            cursor_param="after", cursor_path="paging.next", results_path="data"
+        )
+        data: dict[str, Any] = {"data": [1], "paging.next": "xyz"}
+        assert pag.get_results(data) == [1]
+        assert pag.get_next_params(data) == {"after": "xyz"}
+
+
+class TestPageNumberPaginator:
+    def test_get_results(self) -> None:
+        pag = PageNumberPaginator()
+        data: dict[str, Any] = {"results": [1, 2], "total_pages": 3}
+        assert pag.get_results(data) == [1, 2]
+
+    def test_get_next_params(self) -> None:
+        pag = PageNumberPaginator()
+        data: dict[str, Any] = {"results": [], "total_pages": 3}
+        params = pag.get_next_params(data)
+        assert params == {"page": "2"}
+
+    def test_get_next_params_last_page(self) -> None:
+        pag = PageNumberPaginator()
+        pag._current_page = 3
+        data: dict[str, Any] = {"results": [], "total_pages": 3}
+        assert pag.get_next_params(data) is None
+
+
+# ── ApiClient Tests ─────────────────────────────────────────────────
+
+
+class TestApiClient:
+    def test_context_manager(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(200, json={"ok": True})
+        )
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.get("/test")
+            assert resp.status_code == 200
+            assert resp.json() == {"ok": True}
+
+    def test_post(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(201, json={"id": 1})
+        )
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.post("/items", json={"name": "test"})
+            assert resp.status_code == 201
+
+    def test_put(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(200, json={"updated": True})
+        )
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.put("/items/1", json={"name": "updated"})
+            assert resp.status_code == 200
+
+    def test_patch(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(200)
+        )
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.patch("/items/1", json={"name": "patched"})
+            assert resp.status_code == 200
+
+    def test_delete(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(204)
+        )
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.delete("/items/1")
+            assert resp.status_code == 204
+
+    def test_with_bearer_auth(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            auth = request.headers.get("Authorization", "")
+            return httpx.Response(200, json={"auth": auth})
+
+        transport = httpx.MockTransport(handler)
+        with ApiClient(
+            "https://api.example.com", auth=BearerAuth("test-token")
+        ) as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com",
+                transport=transport,
+                auth=BearerAuth("test-token"),
+            )
+            resp = client.get("/me")
+            assert resp.json()["auth"] == "Bearer test-token"
+
+    def test_with_middleware(self) -> None:
+        call_log: list[str] = []
+
+        class LogMiddleware:
+            def process_request(self, request: httpx.Request) -> httpx.Request:
+                call_log.append("request")
+                return request
+
+            def process_response(self, response: httpx.Response) -> httpx.Response:
+                call_log.append("response")
+                return response
+
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(200)
+        )
+        with ApiClient(
+            "https://api.example.com", middlewares=[LogMiddleware()]
+        ) as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            client.get("/test")
+            assert call_log == ["request", "response"]
+
+    def test_retry_middleware(self) -> None:
+        attempt = 0
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            nonlocal attempt
+            attempt += 1
+            if attempt < 3:
+                return httpx.Response(503)
+            return httpx.Response(200, json={"ok": True})
+
+        transport = httpx.MockTransport(handler)
+        retry_mw = RetryMiddleware(max_retries=3, delay=0.0)
+        with ApiClient(
+            "https://api.example.com", middlewares=[retry_mw]
+        ) as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.get("/test")
+            assert resp.status_code == 200
+            assert attempt == 3
+
+    def test_retry_exhausted(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(503)
+        )
+        retry_mw = RetryMiddleware(max_retries=2, delay=0.0)
+        with ApiClient(
+            "https://api.example.com", middlewares=[retry_mw]
+        ) as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            resp = client.get("/test")
+            assert resp.status_code == 503
+
+    def test_paginate_cursor(self) -> None:
+        page = 0
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            nonlocal page
+            page += 1
+            if page == 1:
+                return httpx.Response(
+                    200, json={"results": [1, 2], "next_cursor": "abc"}
+                )
+            return httpx.Response(200, json={"results": [3], "next_cursor": None})
+
+        transport = httpx.MockTransport(handler)
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            all_results: list[Any] = []
+            for batch in client.paginate("/items", CursorPaginator()):
+                all_results.extend(batch)
+            assert all_results == [1, 2, 3]
+
+    def test_paginate_empty(self) -> None:
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(
+                200, json={"results": [], "next_cursor": None}
+            )
+        )
+        with ApiClient("https://api.example.com") as client:
+            client._client = httpx.Client(
+                base_url="https://api.example.com", transport=transport
+            )
+            pages = list(client.paginate("/items", CursorPaginator()))
+            assert pages == []