crosspoint 0.2.0__tar.gz → 0.3.0__tar.gz

{crosspoint-0.2.0 → crosspoint-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: crosspoint
-Version: 0.2.0
+Version: 0.3.0
 Summary: Crosspoint API client: the Polar SDK, pointed at Crosspoint
 Project-URL: Documentation, https://app.crosspoint.finance/docs/africa/sdks
 License-Expression: MIT
@@ -44,4 +44,7 @@ except WebhookVerificationError:
     ...  # not from Crosspoint: reject it
 ```
 
+Sandbox (test cards, no real money): set `CROSSPOINT_ENVIRONMENT=sandbox` with a sandbox
+access token, or `Crosspoint(server="sandbox")`.
+
 Docs: https://app.crosspoint.finance/docs/africa/sdks

{crosspoint-0.2.0 → crosspoint-0.3.0}/README.md

@@ -34,4 +34,7 @@ except WebhookVerificationError:
     ...  # not from Crosspoint: reject it
 ```
 
+Sandbox (test cards, no real money): set `CROSSPOINT_ENVIRONMENT=sandbox` with a sandbox
+access token, or `Crosspoint(server="sandbox")`.
+
 Docs: https://app.crosspoint.finance/docs/africa/sdks

{crosspoint-0.2.0 → crosspoint-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crosspoint"
-version = "0.2.0"
+version = "0.3.0"
 description = "Crosspoint API client: the Polar SDK, pointed at Crosspoint"
 readme = "README.md"
 license = "MIT"

crosspoint-0.3.0/src/crosspoint/__init__.py

@@ -0,0 +1,24 @@
+"""Crosspoint API client: the Polar SDK, pointed at Crosspoint.
+
+The default API version is 2026-10; pin one with ``from crosspoint.v2026_10 import ...``.
+"""
+
+from . import webhooks
+from .v2026_10 import (
+    CROSSPOINT_API_URL,
+    CROSSPOINT_SANDBOX_API_URL,
+    SPLIT_METADATA_KEY,
+    CrosspointAPIError,
+    Crosspoint,
+    CrosspointAsync,
+)
+
+__all__ = [
+    "CROSSPOINT_API_URL",
+    "CROSSPOINT_SANDBOX_API_URL",
+    "SPLIT_METADATA_KEY",
+    "Crosspoint",
+    "CrosspointAPIError",
+    "CrosspointAsync",
+    "webhooks",
+]

crosspoint-0.3.0/src/crosspoint/_options.py

@@ -0,0 +1,38 @@
+"""Crosspoint's API is Polar's API: the Polar SDK works once it points at Crosspoint."""
+
+import os
+from typing import Literal
+
+CROSSPOINT_API_URL = "https://api.crosspoint.finance"
+CROSSPOINT_SANDBOX_API_URL = "https://sandbox-api.crosspoint.finance"
+ACCESS_TOKEN_ENV = "CROSSPOINT_ACCESS_TOKEN"
+ENVIRONMENT_ENV = "CROSSPOINT_ENVIRONMENT"
+
+# "sandbox" is Crosspoint's test environment: test cards, no real money.
+Server = Literal["production", "sandbox"]
+API_URLS: dict[str, str] = {
+    "production": CROSSPOINT_API_URL,
+    "sandbox": CROSSPOINT_SANDBOX_API_URL,
+}
+
+
+def resolve_access_token(access_token: str | None) -> str:
+    token = access_token or os.environ.get(ACCESS_TOKEN_ENV)
+    if not token:
+        raise ValueError(
+            f"Crosspoint: pass access_token or set {ACCESS_TOKEN_ENV} "
+            "(an organization access token, cxp_oat_...)."
+        )
+    return token
+
+
+def resolve_base_url(base_url: str | None, server: str | None) -> str:
+    """`base_url` wins; else `server`, then CROSSPOINT_ENVIRONMENT, then production."""
+    if base_url:
+        return base_url
+    server = server or os.environ.get(ENVIRONMENT_ENV) or "production"
+    if server not in API_URLS:
+        raise ValueError(
+            f'Crosspoint: server must be "production" or "sandbox", not "{server}".'
+        )
+    return API_URLS[server]

crosspoint-0.3.0/src/crosspoint/_splits.py

@@ -0,0 +1,162 @@
+"""Transaction splits (/v1/splits, /v1/split-recipients): Crosspoint's own endpoints,
+so the Polar SDK doesn't have them. Requests and responses are plain dicts, with the
+API's field names."""
+
+from collections.abc import Sequence
+from typing import Any
+
+import httpx
+
+# Put a split's ID here in a checkout's (or checkout link's) metadata to use it.
+SPLIT_METADATA_KEY = "crosspoint_split"
+
+JSON = dict[str, Any]
+
+
+class CrosspointAPIError(Exception):
+    """A non-2xx answer from the API; `body` has the details (e.g. validation errors)."""
+
+    def __init__(self, status_code: int, body: Any) -> None:
+        super().__init__(f"Crosspoint API error {status_code}: {body}")
+        self.status_code = status_code
+        self.body = body
+
+
+def _answer(response: httpx.Response) -> Any:
+    data = response.json() if response.content else None
+    if response.is_error:
+        raise CrosspointAPIError(response.status_code, data)
+    return data
+
+
+def _params(
+    organization_id: str | Sequence[str] | None,
+    page: int | None,
+    limit: int | None,
+    **extra: Any,
+) -> list[tuple[str, str]]:
+    ids = [organization_id] if isinstance(organization_id, str) else organization_id or []
+    params = [("organization_id", str(id)) for id in ids]
+    for key, value in {"page": page, "limit": limit, **extra}.items():
+        if value is not None:
+            params.append((key, str(value)))
+    return params
+
+
+def _client(cls: type, access_token: str, base_url: str, timeout: Any) -> Any:
+    return cls(
+        base_url=base_url,
+        headers={"Authorization": f"Bearer {access_token}", "Accept": "application/json"},
+        timeout=timeout,
+    )
+
+
+class _Resource:
+    def __init__(self, http: httpx.Client, path: str) -> None:
+        self._http = http
+        self._path = path
+
+    def get(self, id: str) -> JSON:
+        return _answer(self._http.get(f"{self._path}/{id}"))
+
+    def create(self, body: JSON) -> JSON:
+        return _answer(self._http.post(f"{self._path}/", json=body))
+
+    def update(self, id: str, body: JSON) -> JSON:
+        return _answer(self._http.patch(f"{self._path}/{id}", json=body))
+
+    def delete(self, id: str) -> None:
+        _answer(self._http.delete(f"{self._path}/{id}"))
+
+
+class Splits(_Resource):
+    def __init__(self, http: httpx.Client) -> None:
+        super().__init__(http, "/v1/splits")
+
+    def list(
+        self,
+        *,
+        organization_id: str | Sequence[str] | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+    ) -> JSON:
+        params = _params(organization_id, page, limit)
+        return _answer(self._http.get(f"{self._path}/", params=params))
+
+
+class SplitRecipients(_Resource):
+    def __init__(self, http: httpx.Client) -> None:
+        super().__init__(http, "/v1/split-recipients")
+
+    def list(
+        self,
+        *,
+        organization_id: str | Sequence[str] | None = None,
+        status: str | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+    ) -> JSON:
+        params = _params(organization_id, page, limit, status=status)
+        return _answer(self._http.get(f"{self._path}/", params=params))
+
+
+class _AsyncResource:
+    def __init__(self, http: httpx.AsyncClient, path: str) -> None:
+        self._http = http
+        self._path = path
+
+    async def get(self, id: str) -> JSON:
+        return _answer(await self._http.get(f"{self._path}/{id}"))
+
+    async def create(self, body: JSON) -> JSON:
+        return _answer(await self._http.post(f"{self._path}/", json=body))
+
+    async def update(self, id: str, body: JSON) -> JSON:
+        return _answer(await self._http.patch(f"{self._path}/{id}", json=body))
+
+    async def delete(self, id: str) -> None:
+        _answer(await self._http.delete(f"{self._path}/{id}"))
+
+
+class AsyncSplits(_AsyncResource):
+    def __init__(self, http: httpx.AsyncClient) -> None:
+        super().__init__(http, "/v1/splits")
+
+    async def list(
+        self,
+        *,
+        organization_id: str | Sequence[str] | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+    ) -> JSON:
+        params = _params(organization_id, page, limit)
+        return _answer(await self._http.get(f"{self._path}/", params=params))
+
+
+class AsyncSplitRecipients(_AsyncResource):
+    def __init__(self, http: httpx.AsyncClient) -> None:
+        super().__init__(http, "/v1/split-recipients")
+
+    async def list(
+        self,
+        *,
+        organization_id: str | Sequence[str] | None = None,
+        status: str | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+    ) -> JSON:
+        params = _params(organization_id, page, limit, status=status)
+        return _answer(await self._http.get(f"{self._path}/", params=params))
+
+
+def attach(client: Any, access_token: str, base_url: str, timeout: Any) -> None:
+    """`client.splits` and `client.split_recipients` on a sync client."""
+    http = _client(httpx.Client, access_token, base_url, timeout)
+    client.splits = Splits(http)
+    client.split_recipients = SplitRecipients(http)
+
+
+def attach_async(client: Any, access_token: str, base_url: str, timeout: Any) -> None:
+    http = _client(httpx.AsyncClient, access_token, base_url, timeout)
+    client.splits = AsyncSplits(http)
+    client.split_recipients = AsyncSplitRecipients(http)

crosspoint-0.3.0/src/crosspoint/v2026_04/__init__.py

@@ -0,0 +1,77 @@
+"""Crosspoint client for API version 2026_04."""
+
+from typing import Any
+
+from polar.v2026_04 import Polar, PolarAsync
+
+from .._options import (
+    CROSSPOINT_API_URL,
+    CROSSPOINT_SANDBOX_API_URL,
+    Server,
+    resolve_access_token,
+    resolve_base_url,
+)
+from .._splits import (
+    SPLIT_METADATA_KEY,
+    AsyncSplitRecipients,
+    AsyncSplits,
+    CrosspointAPIError,
+    SplitRecipients,
+    Splits,
+    attach,
+    attach_async,
+)
+from . import webhooks
+
+__all__ = [
+    "CROSSPOINT_API_URL",
+    "CROSSPOINT_SANDBOX_API_URL",
+    "SPLIT_METADATA_KEY",
+    "CrosspointAPIError",
+    "Crosspoint",
+    "CrosspointAsync",
+    "webhooks",
+]
+
+
+class Crosspoint(Polar):
+    """
+    `Crosspoint()` reads CROSSPOINT_ACCESS_TOKEN. `server="sandbox"` (or
+    CROSSPOINT_ENVIRONMENT=sandbox) uses the sandbox; `base_url` is for local development.
+    """
+
+    splits: Splits
+    split_recipients: SplitRecipients
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        server: Server | None = None,
+        base_url: str | None = None,
+        timeout: Any = 5.0,
+    ) -> None:
+        token = resolve_access_token(access_token)
+        url = resolve_base_url(base_url, server)
+        super().__init__(token, base_url=url, timeout=timeout)
+        attach(self, token, url, timeout)
+
+
+class CrosspointAsync(PolarAsync):
+    """Async client: `async with CrosspointAsync() as crosspoint: ...`."""
+
+    splits: AsyncSplits
+    split_recipients: AsyncSplitRecipients
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        server: Server | None = None,
+        base_url: str | None = None,
+        timeout: Any = 5.0,
+    ) -> None:
+        token = resolve_access_token(access_token)
+        url = resolve_base_url(base_url, server)
+        super().__init__(token, base_url=url, timeout=timeout)
+        attach_async(self, token, url, timeout)

crosspoint-0.3.0/src/crosspoint/v2026_10/__init__.py

@@ -0,0 +1,77 @@
+"""Crosspoint client for API version 2026_10."""
+
+from typing import Any
+
+from polar.v2026_10 import Polar, PolarAsync
+
+from .._options import (
+    CROSSPOINT_API_URL,
+    CROSSPOINT_SANDBOX_API_URL,
+    Server,
+    resolve_access_token,
+    resolve_base_url,
+)
+from .._splits import (
+    SPLIT_METADATA_KEY,
+    AsyncSplitRecipients,
+    AsyncSplits,
+    CrosspointAPIError,
+    SplitRecipients,
+    Splits,
+    attach,
+    attach_async,
+)
+from . import webhooks
+
+__all__ = [
+    "CROSSPOINT_API_URL",
+    "CROSSPOINT_SANDBOX_API_URL",
+    "SPLIT_METADATA_KEY",
+    "CrosspointAPIError",
+    "Crosspoint",
+    "CrosspointAsync",
+    "webhooks",
+]
+
+
+class Crosspoint(Polar):
+    """
+    `Crosspoint()` reads CROSSPOINT_ACCESS_TOKEN. `server="sandbox"` (or
+    CROSSPOINT_ENVIRONMENT=sandbox) uses the sandbox; `base_url` is for local development.
+    """
+
+    splits: Splits
+    split_recipients: SplitRecipients
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        server: Server | None = None,
+        base_url: str | None = None,
+        timeout: Any = 5.0,
+    ) -> None:
+        token = resolve_access_token(access_token)
+        url = resolve_base_url(base_url, server)
+        super().__init__(token, base_url=url, timeout=timeout)
+        attach(self, token, url, timeout)
+
+
+class CrosspointAsync(PolarAsync):
+    """Async client: `async with CrosspointAsync() as crosspoint: ...`."""
+
+    splits: AsyncSplits
+    split_recipients: AsyncSplitRecipients
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        server: Server | None = None,
+        base_url: str | None = None,
+        timeout: Any = 5.0,
+    ) -> None:
+        token = resolve_access_token(access_token)
+        url = resolve_base_url(base_url, server)
+        super().__init__(token, base_url=url, timeout=timeout)
+        attach_async(self, token, url, timeout)

crosspoint-0.3.0/src/crosspoint/v2027_01/__init__.py

@@ -0,0 +1,77 @@
+"""Crosspoint client for API version 2027_01."""
+
+from typing import Any
+
+from polar.v2027_01 import Polar, PolarAsync
+
+from .._options import (
+    CROSSPOINT_API_URL,
+    CROSSPOINT_SANDBOX_API_URL,
+    Server,
+    resolve_access_token,
+    resolve_base_url,
+)
+from .._splits import (
+    SPLIT_METADATA_KEY,
+    AsyncSplitRecipients,
+    AsyncSplits,
+    CrosspointAPIError,
+    SplitRecipients,
+    Splits,
+    attach,
+    attach_async,
+)
+from . import webhooks
+
+__all__ = [
+    "CROSSPOINT_API_URL",
+    "CROSSPOINT_SANDBOX_API_URL",
+    "SPLIT_METADATA_KEY",
+    "CrosspointAPIError",
+    "Crosspoint",
+    "CrosspointAsync",
+    "webhooks",
+]
+
+
+class Crosspoint(Polar):
+    """
+    `Crosspoint()` reads CROSSPOINT_ACCESS_TOKEN. `server="sandbox"` (or
+    CROSSPOINT_ENVIRONMENT=sandbox) uses the sandbox; `base_url` is for local development.
+    """
+
+    splits: Splits
+    split_recipients: SplitRecipients
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        server: Server | None = None,
+        base_url: str | None = None,
+        timeout: Any = 5.0,
+    ) -> None:
+        token = resolve_access_token(access_token)
+        url = resolve_base_url(base_url, server)
+        super().__init__(token, base_url=url, timeout=timeout)
+        attach(self, token, url, timeout)
+
+
+class CrosspointAsync(PolarAsync):
+    """Async client: `async with CrosspointAsync() as crosspoint: ...`."""
+
+    splits: AsyncSplits
+    split_recipients: AsyncSplitRecipients
+
+    def __init__(
+        self,
+        access_token: str | None = None,
+        *,
+        server: Server | None = None,
+        base_url: str | None = None,
+        timeout: Any = 5.0,
+    ) -> None:
+        token = resolve_access_token(access_token)
+        url = resolve_base_url(base_url, server)
+        super().__init__(token, base_url=url, timeout=timeout)
+        attach_async(self, token, url, timeout)

crosspoint-0.3.0/tests/test_client.py

@@ -0,0 +1,126 @@
+import httpx
+import pytest
+
+from crosspoint import CROSSPOINT_API_URL, Crosspoint
+from crosspoint.v2026_04 import Crosspoint as Crosspoint202604
+
+
+def http(client: Crosspoint) -> httpx.Client:
+    return client._client._client  # the SDK's httpx client
+
+
+def test_talks_to_crosspoint_not_polar() -> None:
+    client = http(Crosspoint("cxp_oat_test"))
+
+    assert str(client.base_url).rstrip("/") == CROSSPOINT_API_URL
+    assert client.headers["authorization"] == "Bearer cxp_oat_test"
+
+
+def test_local_development_url() -> None:
+    client = http(Crosspoint("cxp_oat_test", base_url="http://127.0.0.1:8001"))
+    assert str(client.base_url).rstrip("/") == "http://127.0.0.1:8001"
+
+
+def test_reads_the_environment(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("CROSSPOINT_ACCESS_TOKEN", "cxp_oat_env")
+    Crosspoint()
+    Crosspoint202604()
+
+
+def test_explains_a_missing_token(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("CROSSPOINT_ACCESS_TOKEN", raising=False)
+    with pytest.raises(ValueError, match="CROSSPOINT_ACCESS_TOKEN"):
+        Crosspoint()
+
+
+def test_every_api_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    from crosspoint.v2027_01 import Crosspoint as Crosspoint202701
+
+    client = http(Crosspoint202701("cxp_oat_test"))
+    assert str(client.base_url).rstrip("/") == CROSSPOINT_API_URL
+
+
+def test_webhooks_import_paths() -> None:
+    import crosspoint
+    from crosspoint.v2027_01.webhooks import validate_event as pinned
+    from crosspoint.webhooks import (
+        PolarWebhookVerificationError,
+        WebhookUnknownTypeError,
+        WebhookVerificationError,
+        validate_event,
+    )
+
+    assert crosspoint.webhooks.validate_event is validate_event
+    assert callable(pinned)
+    assert WebhookVerificationError is PolarWebhookVerificationError
+    assert issubclass(WebhookUnknownTypeError, Exception)
+    with pytest.raises(WebhookVerificationError):
+        validate_event(
+            "{}",
+            {
+                "webhook-id": "x",
+                "webhook-timestamp": "1",
+                "webhook-signature": "v1,bad",
+            },
+            "secret",
+        )
+
+
+def test_sandbox(monkeypatch: pytest.MonkeyPatch) -> None:
+    from crosspoint import CROSSPOINT_SANDBOX_API_URL
+
+    assert CROSSPOINT_SANDBOX_API_URL == "https://sandbox-api.crosspoint.finance"
+    client = http(Crosspoint("cxp_oat_test", server="sandbox"))
+    assert str(client.base_url).rstrip("/") == CROSSPOINT_SANDBOX_API_URL
+
+    monkeypatch.setenv("CROSSPOINT_ENVIRONMENT", "sandbox")
+    client = http(Crosspoint202604("cxp_oat_test"))
+    assert str(client.base_url).rstrip("/") == CROSSPOINT_SANDBOX_API_URL
+
+
+def test_unknown_server() -> None:
+    with pytest.raises(ValueError, match="production"):
+        Crosspoint("cxp_oat_test", server="staging")  # type: ignore[arg-type]
+
+
+def test_splits() -> None:
+    from crosspoint import SPLIT_METADATA_KEY, CrosspointAPIError
+
+    calls: list[httpx.Request] = []
+
+    def answer(request: httpx.Request) -> httpx.Response:
+        calls.append(request)
+        if request.method == "GET":
+            return httpx.Response(422, json={"detail": [{"msg": "Bad status"}]})
+        return httpx.Response(201, json={"id": "spl_1", "fee_bearer": "shared"})
+
+    client = Crosspoint("cxp_oat_test", base_url="http://127.0.0.1:8001")
+    client.splits._http._transport = httpx.MockTransport(answer)
+
+    split = client.splits.create({"name": "Partners", "shares": []})
+    assert split == {"id": "spl_1", "fee_bearer": "shared"}
+    assert str(calls[0].url) == "http://127.0.0.1:8001/v1/splits/"
+    assert calls[0].headers["authorization"] == "Bearer cxp_oat_test"
+
+    client.split_recipients._http._transport = httpx.MockTransport(answer)
+    with pytest.raises(CrosspointAPIError) as error:
+        client.split_recipients.list(organization_id=["a", "b"], status="pending")
+    assert error.value.status_code == 422
+    assert str(calls[1].url) == (
+        "http://127.0.0.1:8001/v1/split-recipients/"
+        "?organization_id=a&organization_id=b&status=pending"
+    )
+    assert SPLIT_METADATA_KEY == "crosspoint_split"
+
+
+def test_async_splits() -> None:
+    import asyncio
+
+    from crosspoint import CrosspointAsync
+
+    def answer(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(204)
+
+    client = CrosspointAsync("cxp_oat_test")
+    client.splits._http._transport = httpx.MockTransport(answer)
+    assert asyncio.run(client.splits.delete("spl_1")) is None

{crosspoint-0.2.0 → crosspoint-0.3.0}/uv.lock

@@ -44,7 +44,7 @@ wheels = [
 
 [[package]]
 name = "crosspoint"
-version = "0.2.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "polar-sdk" },

crosspoint-0.2.0/src/crosspoint/__init__.py

@@ -1,9 +0,0 @@
-"""Crosspoint API client: the Polar SDK, pointed at Crosspoint.
-
-The default API version is 2026-10; pin one with ``from crosspoint.v2026_10 import ...``.
-"""
-
-from . import webhooks
-from .v2026_10 import CROSSPOINT_API_URL, Crosspoint, CrosspointAsync
-
-__all__ = ["CROSSPOINT_API_URL", "Crosspoint", "CrosspointAsync", "webhooks"]

crosspoint-0.2.0/src/crosspoint/_options.py

@@ -1,16 +0,0 @@
-"""Crosspoint's API is Polar's API: the Polar SDK works once it points at Crosspoint."""
-
-import os
-
-CROSSPOINT_API_URL = "https://api.crosspoint.finance"
-ACCESS_TOKEN_ENV = "CROSSPOINT_ACCESS_TOKEN"
-
-
-def resolve_access_token(access_token: str | None) -> str:
-    token = access_token or os.environ.get(ACCESS_TOKEN_ENV)
-    if not token:
-        raise ValueError(
-            f"Crosspoint: pass access_token or set {ACCESS_TOKEN_ENV} "
-            "(an organization access token, cxp_oat_...)."
-        )
-    return token

crosspoint-0.2.0/src/crosspoint/v2026_04/__init__.py

@@ -1,40 +0,0 @@
-"""Crosspoint client for API version 2026_04."""
-
-from typing import Any
-
-from polar.v2026_04 import Polar, PolarAsync
-
-from .._options import CROSSPOINT_API_URL, resolve_access_token
-from . import webhooks
-
-__all__ = ["CROSSPOINT_API_URL", "Crosspoint", "CrosspointAsync", "webhooks"]
-
-
-class Crosspoint(Polar):
-    """`Crosspoint()` reads CROSSPOINT_ACCESS_TOKEN; pass `base_url` only for local development."""
-
-    def __init__(
-        self,
-        access_token: str | None = None,
-        *,
-        base_url: str = CROSSPOINT_API_URL,
-        timeout: Any = 5.0,
-    ) -> None:
-        super().__init__(
-            resolve_access_token(access_token), base_url=base_url, timeout=timeout
-        )
-
-
-class CrosspointAsync(PolarAsync):
-    """Async client: `async with CrosspointAsync() as crosspoint: ...`."""
-
-    def __init__(
-        self,
-        access_token: str | None = None,
-        *,
-        base_url: str = CROSSPOINT_API_URL,
-        timeout: Any = 5.0,
-    ) -> None:
-        super().__init__(
-            resolve_access_token(access_token), base_url=base_url, timeout=timeout
-        )

crosspoint-0.2.0/src/crosspoint/v2026_10/__init__.py

@@ -1,40 +0,0 @@
-"""Crosspoint client for API version 2026_10."""
-
-from typing import Any
-
-from polar.v2026_10 import Polar, PolarAsync
-
-from .._options import CROSSPOINT_API_URL, resolve_access_token
-from . import webhooks
-
-__all__ = ["CROSSPOINT_API_URL", "Crosspoint", "CrosspointAsync", "webhooks"]
-
-
-class Crosspoint(Polar):
-    """`Crosspoint()` reads CROSSPOINT_ACCESS_TOKEN; pass `base_url` only for local development."""
-
-    def __init__(
-        self,
-        access_token: str | None = None,
-        *,
-        base_url: str = CROSSPOINT_API_URL,
-        timeout: Any = 5.0,
-    ) -> None:
-        super().__init__(
-            resolve_access_token(access_token), base_url=base_url, timeout=timeout
-        )
-
-
-class CrosspointAsync(PolarAsync):
-    """Async client: `async with CrosspointAsync() as crosspoint: ...`."""
-
-    def __init__(
-        self,
-        access_token: str | None = None,
-        *,
-        base_url: str = CROSSPOINT_API_URL,
-        timeout: Any = 5.0,
-    ) -> None:
-        super().__init__(
-            resolve_access_token(access_token), base_url=base_url, timeout=timeout
-        )

crosspoint-0.2.0/src/crosspoint/v2027_01/__init__.py

@@ -1,40 +0,0 @@
-"""Crosspoint client for API version 2027_01."""
-
-from typing import Any
-
-from polar.v2027_01 import Polar, PolarAsync
-
-from .._options import CROSSPOINT_API_URL, resolve_access_token
-from . import webhooks
-
-__all__ = ["CROSSPOINT_API_URL", "Crosspoint", "CrosspointAsync", "webhooks"]
-
-
-class Crosspoint(Polar):
-    """`Crosspoint()` reads CROSSPOINT_ACCESS_TOKEN; pass `base_url` only for local development."""
-
-    def __init__(
-        self,
-        access_token: str | None = None,
-        *,
-        base_url: str = CROSSPOINT_API_URL,
-        timeout: Any = 5.0,
-    ) -> None:
-        super().__init__(
-            resolve_access_token(access_token), base_url=base_url, timeout=timeout
-        )
-
-
-class CrosspointAsync(PolarAsync):
-    """Async client: `async with CrosspointAsync() as crosspoint: ...`."""
-
-    def __init__(
-        self,
-        access_token: str | None = None,
-        *,
-        base_url: str = CROSSPOINT_API_URL,
-        timeout: Any = 5.0,
-    ) -> None:
-        super().__init__(
-            resolve_access_token(access_token), base_url=base_url, timeout=timeout
-        )

crosspoint-0.2.0/tests/test_client.py

@@ -1,66 +0,0 @@
-import httpx
-import pytest
-
-from crosspoint import CROSSPOINT_API_URL, Crosspoint
-from crosspoint.v2026_04 import Crosspoint as Crosspoint202604
-
-
-def http(client: Crosspoint) -> httpx.Client:
-    return client._client._client  # the SDK's httpx client
-
-
-def test_talks_to_crosspoint_not_polar() -> None:
-    client = http(Crosspoint("cxp_oat_test"))
-
-    assert str(client.base_url).rstrip("/") == CROSSPOINT_API_URL
-    assert client.headers["authorization"] == "Bearer cxp_oat_test"
-
-
-def test_local_development_url() -> None:
-    client = http(Crosspoint("cxp_oat_test", base_url="http://127.0.0.1:8001"))
-    assert str(client.base_url).rstrip("/") == "http://127.0.0.1:8001"
-
-
-def test_reads_the_environment(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("CROSSPOINT_ACCESS_TOKEN", "cxp_oat_env")
-    Crosspoint()
-    Crosspoint202604()
-
-
-def test_explains_a_missing_token(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("CROSSPOINT_ACCESS_TOKEN", raising=False)
-    with pytest.raises(ValueError, match="CROSSPOINT_ACCESS_TOKEN"):
-        Crosspoint()
-
-
-def test_every_api_version(monkeypatch: pytest.MonkeyPatch) -> None:
-    from crosspoint.v2027_01 import Crosspoint as Crosspoint202701
-
-    client = http(Crosspoint202701("cxp_oat_test"))
-    assert str(client.base_url).rstrip("/") == CROSSPOINT_API_URL
-
-
-def test_webhooks_import_paths() -> None:
-    import crosspoint
-    from crosspoint.v2027_01.webhooks import validate_event as pinned
-    from crosspoint.webhooks import (
-        PolarWebhookVerificationError,
-        WebhookUnknownTypeError,
-        WebhookVerificationError,
-        validate_event,
-    )
-
-    assert crosspoint.webhooks.validate_event is validate_event
-    assert callable(pinned)
-    assert WebhookVerificationError is PolarWebhookVerificationError
-    assert issubclass(WebhookUnknownTypeError, Exception)
-    with pytest.raises(WebhookVerificationError):
-        validate_event(
-            "{}",
-            {
-                "webhook-id": "x",
-                "webhook-timestamp": "1",
-                "webhook-signature": "v1,bad",
-            },
-            "secret",
-        )