alphapay 0.1.0__py3-none-any.whl

alphapay/__init__.py

@@ -0,0 +1,36 @@
+"""Official Python SDK for the AlphaPay payment aggregator API."""
+
+from .client import AlphaPayClient
+from .exceptions import (
+    AlphaPayAuthenticationError,
+    AlphaPayConnectionError,
+    AlphaPayError,
+    AlphaPayIdempotencyError,
+    AlphaPayNotFoundError,
+    AlphaPayPermissionError,
+    AlphaPayRateLimitError,
+    AlphaPayServerError,
+    AlphaPayValidationError,
+    AlphaPayWebhookSignatureError,
+)
+from .pagination import paginate
+from .webhook import verify_signature
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AlphaPayClient",
+    "AlphaPayError",
+    "AlphaPayAuthenticationError",
+    "AlphaPayPermissionError",
+    "AlphaPayNotFoundError",
+    "AlphaPayValidationError",
+    "AlphaPayRateLimitError",
+    "AlphaPayServerError",
+    "AlphaPayConnectionError",
+    "AlphaPayIdempotencyError",
+    "AlphaPayWebhookSignatureError",
+    "verify_signature",
+    "paginate",
+    "__version__",
+]

alphapay/client.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from .http import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, Http
+from .resources.api_keys import ApiKeysResource
+from .resources.balances import BalancesResource
+from .resources.checkout_sessions import CheckoutSessionsResource
+from .resources.customers import CustomersResource
+from .resources.payment_links import PaymentLinksResource
+from .resources.settlements import SettlementsResource
+from .resources.transactions import TransactionsResource
+from .resources.wallet_transfers import WalletTransfersResource
+from .resources.webhook_endpoints import WebhookEndpointsResource
+
+
+class AlphaPayClient:
+    """Client principal du SDK AlphaPay. Une instance = une clé API = un
+    marchand + un environnement (live/sandbox, déduit automatiquement du
+    préfixe de la clé -- ``sk_live_...`` ou ``sk_test_...``).
+
+    :Example:
+
+    >>> alphapay = AlphaPayClient(os.environ["ALPHAPAY_SECRET_KEY"])
+    >>> payment = alphapay.transactions.payin_initialize(
+    ...     amount=5000,
+    ...     currency="XOF",
+    ...     country="BJ",
+    ...     network="mtn_bj",
+    ...     customer={"email": "client@exemple.com", "first_name": "Client", "last_name": "Test", "phone": "+22900000000"},
+    ...     idempotency_key=True,
+    ... )
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+    ) -> None:
+        #: Client HTTP bas niveau -- nécessaire à :func:`alphapay.pagination.paginate`
+        #: pour suivre un lien "next" (URL absolue renvoyée par l'API), pas
+        #: destiné à un usage direct en dehors de ce cas.
+        self.http = Http(api_key, base_url, timeout, max_retries)
+        self.environment = self.http.environment
+
+        self.transactions = TransactionsResource(self.http)
+        self.payment_links = PaymentLinksResource(self.http)
+        self.checkout_sessions = CheckoutSessionsResource(self.http)
+        self.customers = CustomersResource(self.http)
+        self.settlements = SettlementsResource(self.http)
+        self.wallet_transfers = WalletTransfersResource(self.http)
+        self.balances = BalancesResource(self.http)
+        self.api_keys = ApiKeysResource(self.http)
+        self.webhook_endpoints = WebhookEndpointsResource(self.http)

alphapay/exceptions.py

@@ -0,0 +1,138 @@
+"""
+Toute erreur API passe par apps.core.renderers.StandardJSONRenderer côté
+AlphaPayBack :
+    {"success": false, "error": <forme variable>, "code": <statut HTTP>}
+`error` n'a PAS une forme unique :
+    - erreurs de validation DRF      -> {"champ": ["message", ...], ...}
+    - erreurs métier personnalisées  -> {"message": "...", "code": "<code_machine>"}
+    - erreurs d'authentification/permission -> {"detail": "..."}
+str(exception) normalise ces trois formes en une seule chaîne lisible ;
+`.raw` garde la forme originale pour qui a besoin du détail par champ.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class AlphaPayError(Exception):
+    """Exception de base -- toutes les erreurs API en sont une sous-classe."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        error_code: Optional[str] = None,
+        raw: Any = None,
+        field_errors: Optional[Dict[str, List[str]]] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        #: Code machine, quand l'API en fournit un (ex. "dashboard_only", "invalid_file_type") --
+        #: absent sur les erreurs de validation par champ.
+        self.error_code = error_code
+        #: Corps d'erreur brut, tel que renvoyé par l'API.
+        self.raw = raw
+        #: Présent uniquement sur une erreur de validation DRF ({"champ": [...]}).
+        self.field_errors = field_errors
+        self.request_id = request_id
+
+
+class AlphaPayAuthenticationError(AlphaPayError):
+    pass
+
+
+class AlphaPayPermissionError(AlphaPayError):
+    pass
+
+
+class AlphaPayNotFoundError(AlphaPayError):
+    pass
+
+
+class AlphaPayValidationError(AlphaPayError):
+    pass
+
+
+class AlphaPayRateLimitError(AlphaPayError):
+    """429 -- `retry_after` (secondes) est renseigné quand l'API précise un header Retry-After."""
+
+    def __init__(self, message: str, *, retry_after: Optional[int] = None, **kwargs: Any) -> None:
+        super().__init__(message, **kwargs)
+        self.retry_after = retry_after
+
+
+class AlphaPayServerError(AlphaPayError):
+    pass
+
+
+class AlphaPayConnectionError(AlphaPayError):
+    """Connexion/DNS/timeout -- jamais atteint le serveur AlphaPay, `status` vaut 0."""
+
+    pass
+
+
+class AlphaPayIdempotencyError(AlphaPayError):
+    """409 -- Idempotency-Key réutilisée avec un payload différent (cf. apps.core.mixins.IdempotencyMixin côté API)."""
+
+    pass
+
+
+class AlphaPayWebhookSignatureError(Exception):
+    """Levée par alphapay.webhook.verify_signature() -- signature invalide ou timestamp hors fenêtre de tolérance (rejeu)."""
+
+    pass
+
+
+def error_from_response(status: int, body: Any, request_id: Optional[str] = None) -> AlphaPayError:
+    """Construit l'exception normalisée à partir de la réponse HTTP. `body` est
+    déjà le contenu de la clé "error" de l'enveloppe (pas l'enveloppe entière).
+    """
+    message, error_code, field_errors = _interpret_error_body(body)
+
+    kwargs = dict(status=status, error_code=error_code, raw=body, field_errors=field_errors, request_id=request_id)
+
+    if status == 401:
+        return AlphaPayAuthenticationError(message, **kwargs)
+    if status == 403:
+        return AlphaPayPermissionError(message, **kwargs)
+    if status == 404:
+        return AlphaPayNotFoundError(message, **kwargs)
+    if status == 409:
+        return AlphaPayIdempotencyError(message, **kwargs)
+    if status == 429:
+        return AlphaPayRateLimitError(message, **kwargs)
+    if status in (400, 422):
+        return AlphaPayValidationError(message, **kwargs)
+    if status >= 500:
+        return AlphaPayServerError(message, **kwargs)
+    return AlphaPayError(message, **kwargs)
+
+
+def _interpret_error_body(body: Any):
+    if body is None:
+        return "Erreur AlphaPay inconnue.", None, None
+    if isinstance(body, str):
+        return body, None, None
+    if isinstance(body, dict):
+        # {"message": "...", "code": "..."} -- erreurs métier personnalisées.
+        message = body.get("message")
+        if isinstance(message, str):
+            code = body.get("code")
+            return message, code if isinstance(code, str) else None, None
+        # {"detail": "..."} -- erreurs d'auth/permission DRF standard.
+        detail = body.get("detail")
+        if isinstance(detail, str):
+            return detail, None, None
+        # {"champ": ["erreur", ...], ...} -- erreurs de validation DRF.
+        field_errors = {
+            field: value
+            for field, value in body.items()
+            if isinstance(field, str) and isinstance(value, list) and value and all(isinstance(v, str) for v in value)
+        }
+        if field_errors:
+            summary = " — ".join(f"{field}: {', '.join(errors)}" for field, errors in field_errors.items())
+            return summary, None, field_errors
+    return "Erreur AlphaPay inconnue.", None, None

alphapay/http.py

@@ -0,0 +1,198 @@
+"""
+Client HTTP bas niveau, partagé par toutes les ressources. Gère
+l'authentification, l'enveloppe standard {success, data, code}, les retries
+avec backoff sur 429/5xx/erreur réseau, et le mapping vers des exceptions
+typées (cf. exceptions.py) -- chaque ressource (Transactions, PaymentLinks,
+...) n'a plus qu'à décrire le endpoint, jamais la mécanique réseau.
+
+Volontairement stdlib uniquement (urllib), pas de dépendance à `requests` --
+cohérent avec les SDK Node/PHP jumeaux (0 dépendance runtime).
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import secrets
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Optional, Union
+
+from .exceptions import (
+    AlphaPayConnectionError,
+    AlphaPayError,
+    AlphaPayRateLimitError,
+    AlphaPayServerError,
+    error_from_response,
+)
+
+DEFAULT_BASE_URL = "https://api.alphapay.me/api/v1"
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_MAX_RETRIES = 2
+
+
+class Http:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+    ) -> None:
+        if not api_key:
+            raise ValueError("AlphaPayClient: `api_key` est requis.")
+        self._api_key = api_key
+        self.environment = "live" if api_key.startswith("sk_live_") else "sandbox"
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self._timeout = timeout
+        self._max_retries = max_retries
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        idempotency_key: Union[str, bool, None] = None,
+    ) -> Any:
+        # `path` est une URL absolue quand on suit un lien "next"/"previous"
+        # renvoyé tel quel par l'API (cf. pagination.paginate()) -- déjà
+        # complète, avec sa propre query string ; ne jamais la préfixer par
+        # base_url ni y rajouter `query` par-dessus.
+        if path.startswith("http://") or path.startswith("https://"):
+            url = path
+        else:
+            qs = self._build_query_string(query)
+            url = f"{self.base_url}{path}{qs}"
+
+        headers = {"Authorization": f"Bearer {self._api_key}", "Accept": "application/json"}
+        data: Optional[bytes] = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+        if idempotency_key:
+            key = idempotency_key if isinstance(idempotency_key, str) else self._random_idempotency_key()
+            headers["Idempotency-Key"] = key
+
+        attempt = 0
+        while True:
+            try:
+                return self._attempt(method, url, headers, data)
+            except (AlphaPayRateLimitError, AlphaPayServerError) as exc:
+                if attempt >= self._max_retries:
+                    raise
+                retry_after = getattr(exc, "retry_after", None)
+                delay = retry_after if retry_after is not None else self._backoff_seconds(attempt)
+                time.sleep(delay)
+                attempt += 1
+            except AlphaPayConnectionError:
+                if attempt >= self._max_retries:
+                    raise
+                time.sleep(self._backoff_seconds(attempt))
+                attempt += 1
+
+    def request_binary(self, path: str) -> Dict[str, Any]:
+        """Pour les rares endpoints qui répondent en binaire plutôt qu'en JSON
+        (ex. GET /transactions/{id}/invoice/, application/pdf, et
+        /transactions/export/, text/csv) -- bypass l'enveloppe standard,
+        jamais utilisée par un endpoint qui en renvoie une.
+
+        Retourne {"data": bytes, "content_type": str|None, "filename": str|None}.
+        """
+        url = f"{self.base_url}{path}"
+        req = urllib.request.Request(
+            url,
+            headers={"Authorization": f"Bearer {self._api_key}", "Accept": "application/pdf, text/csv, application/octet-stream"},
+            method="GET",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as response:
+                raw = response.read()
+                content_type = response.headers.get("Content-Type")
+                filename = self._extract_filename(response.headers.get("Content-Disposition"))
+                return {"data": raw, "content_type": content_type, "filename": filename}
+        except urllib.error.HTTPError as exc:
+            # Une erreur sur cet endpoint reste en JSON (cf. InvoiceError côté API) --
+            # on retombe sur le mapping JSON normal pour un message exploitable.
+            raise self._error_from_http_error(exc) from exc
+        except socket.timeout as exc:
+            raise AlphaPayConnectionError("Requête AlphaPay expirée.", status=0) from exc
+        except urllib.error.URLError as exc:
+            raise AlphaPayConnectionError(f"Impossible de joindre l'API AlphaPay : {exc.reason}", status=0) from exc
+
+    def _attempt(self, method: str, url: str, headers: Dict[str, str], data: Optional[bytes]) -> Any:
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as response:
+                body = response.read()
+                request_id = response.headers.get("X-Request-Id")
+                return self._unwrap_success(body, request_id)
+        except urllib.error.HTTPError as exc:
+            raise self._error_from_http_error(exc) from exc
+        except socket.timeout as exc:
+            raise AlphaPayConnectionError("Requête AlphaPay expirée.", status=0) from exc
+        except urllib.error.URLError as exc:
+            reason = exc.reason
+            is_timeout = "timed out" in str(reason).lower()
+            message = "Requête AlphaPay expirée." if is_timeout else f"Impossible de joindre l'API AlphaPay : {reason}"
+            raise AlphaPayConnectionError(message, status=0) from exc
+
+    def _error_from_http_error(self, exc: urllib.error.HTTPError) -> AlphaPayError:
+        request_id = exc.headers.get("X-Request-Id") if exc.headers else None
+        raw_body = exc.read()
+        json_body = self._try_parse_json(raw_body)
+        error_body = json_body.get("error") if isinstance(json_body, dict) and "error" in json_body else json_body
+        error = error_from_response(exc.code, error_body, request_id)
+        if isinstance(error, AlphaPayRateLimitError):
+            retry_after = exc.headers.get("Retry-After") if exc.headers else None
+            error.retry_after = int(retry_after) if retry_after else None
+        return error
+
+    def _unwrap_success(self, raw_body: bytes, request_id: Optional[str]) -> Any:
+        json_body = self._try_parse_json(raw_body)
+        if isinstance(json_body, dict) and "data" in json_body:
+            return json_body["data"]
+        return json_body
+
+    @staticmethod
+    def _try_parse_json(raw_body: bytes) -> Any:
+        if not raw_body:
+            return None
+        try:
+            return json.loads(raw_body)
+        except json.JSONDecodeError:
+            # Réponse non-JSON (page d'erreur d'un proxy en amont, ex. 502 Traefik) --
+            # traité comme une absence de corps exploitable.
+            return None
+
+    @staticmethod
+    def _build_query_string(query: Optional[Dict[str, Any]]) -> str:
+        if not query:
+            return ""
+        filtered = {k: v for k, v in query.items() if v is not None}
+        if not filtered:
+            return ""
+        return "?" + urllib.parse.urlencode(filtered)
+
+    @staticmethod
+    def _backoff_seconds(attempt: int) -> float:
+        # Backoff exponentiel + gigue : 0.4-0.6s, 0.8-1.2s, 1.6-2.4s...
+        base = 0.4 * (2**attempt)
+        return base + random.uniform(0, base * 0.5)
+
+    @staticmethod
+    def _random_idempotency_key() -> str:
+        return f"idem_{secrets.token_hex(16)}"
+
+    @staticmethod
+    def _extract_filename(content_disposition: Optional[str]) -> Optional[str]:
+        if not content_disposition:
+            return None
+        import re
+
+        match = re.search(r'filename="?([^";]+)"?', content_disposition)
+        return match.group(1) if match else None

alphapay/pagination.py

@@ -0,0 +1,36 @@
+"""Itération automatique sur les ressources paginées."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterator
+
+from .http import Http
+
+
+def paginate(http: Http, first_page: Dict[str, Any]) -> Iterator[Any]:
+    """Parcourt automatiquement toutes les pages d'une ressource paginée,
+    qu'elle soit paginée par page (avec "count") ou par curseur (sans
+    "count" -- ex. ``client.transactions.list()``).
+
+    Suit le lien "next" renvoyé TEL QUEL par l'API plutôt que de recalculer
+    un numéro de page soi-même : un curseur n'est pas un numéro de page
+    (c'est un jeton opaque encodant une position dans le tri), l'incrémenter
+    à la main ne ferait qu'interroger indéfiniment la même première page.
+
+    :param http: ``client.http`` -- nécessaire pour requêter l'URL absolue "next".
+    :param first_page: Le premier appel déjà résolu, ex.
+        ``client.transactions.list(status="SUCCESS")``.
+
+    :Example:
+
+    >>> for tx in paginate(client.http, client.transactions.list(status="SUCCESS")):
+    ...     print(tx["reference"])
+    """
+    page = first_page
+    while True:
+        for item in page["results"]:
+            yield item
+        next_url = page.get("next")
+        if not next_url:
+            return
+        page = http.request("GET", next_url)

alphapay/resources/api_keys.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from ..http import Http
+
+
+class IpWhitelistResource:
+    """Whitelist IP requise pour les payouts -- partagée par toutes les
+    clés du marchand (cf. ``apps.api_keys.models.MerchantIpWhitelistEntry``
+    côté API). Fonctionne bien via clé API -- vérifié en conditions réelles.
+    """
+
+    def __init__(self, http: Http) -> None:
+        self._http = http
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        return self._http.request("GET", "/merchant-ip-whitelist/", query=params)
+
+    def create(self, *, ip_address: str, label: Optional[str] = None) -> Dict[str, Any]:
+        body = {k: v for k, v in dict(ip_address=ip_address, label=label).items() if v is not None}
+        return self._http.request("POST", "/merchant-ip-whitelist/", body=body)
+
+    def update(self, id: str, **params: Any) -> Dict[str, Any]:
+        return self._http.request("PATCH", f"/merchant-ip-whitelist/{id}/", body=params)
+
+    def delete(self, id: str) -> None:
+        self._http.request("DELETE", f"/merchant-ip-whitelist/{id}/")
+
+
+class ApiKeysResource:
+    """Gestion des clés API du marchand, et whitelist IP (via ``.ip_whitelist``).
+
+    ATTENTION : ``list``/``create``/``get``/``revoke``/``delete``
+    ci-dessous sont entièrement inaccessibles via clé API (403,
+    ``error_code == "dashboard_only"``, vérifié en conditions réelles) --
+    cohérent avec la sécurité attendue : une clé compromise ne doit pas
+    pouvoir créer d'autres clés pour elle-même ni lister les clés
+    existantes. Seul ``.ip_whitelist`` fonctionne via clé API.
+    """
+
+    def __init__(self, http: Http) -> None:
+        self._http = http
+        self.ip_whitelist = IpWhitelistResource(http)
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        return self._http.request("GET", "/merchant-api-keys/", query=params)
+
+    def create(self, *, environment: str, name: Optional[str] = None, scope: Optional[str] = None, expires_at: Optional[str] = None) -> Dict[str, Any]:
+        """``secret`` n'est présent QUE dans cette réponse -- jamais
+        récupérable ensuite, à stocker immédiatement côté appelant.
+        """
+        body = {k: v for k, v in dict(name=name, environment=environment, scope=scope, expires_at=expires_at).items() if v is not None}
+        return self._http.request("POST", "/merchant-api-keys/", body=body)
+
+    def get(self, id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/merchant-api-keys/{id}/")
+
+    def revoke(self, id: str) -> Dict[str, Any]:
+        return self._http.request("POST", f"/merchant-api-keys/{id}/revoke/")
+
+    def delete(self, id: str) -> None:
+        self._http.request("DELETE", f"/merchant-api-keys/{id}/")

alphapay/resources/balances.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from ..http import Http
+
+
+class BalancesResource:
+    """Soldes par pays/devise et grand livre des mouvements -- lecture seule
+    (les mouvements naissent des autres ressources : transactions,
+    reversements, transferts).
+    """
+
+    def __init__(self, http: Http) -> None:
+        self._http = http
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        return self._http.request("GET", "/merchant-balances/", query=params)
+
+    def get(self, id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/merchant-balances/{id}/")
+
+    def ledger_entries(self, **params: Any) -> Dict[str, Any]:
+        """ATTENTION : inaccessible via clé API (contrairement à
+        :meth:`list`/:meth:`get`, qui fonctionnent bien avec une clé --
+        vérifié en conditions réelles) : lève systématiquement
+        :class:`~alphapay.exceptions.AlphaPayPermissionError` (403,
+        ``error_code == "dashboard_only"``). Le grand livre détaillé n'est
+        consultable que depuis le dashboard (compte utilisateur).
+
+        Filtres reconnus : ``page``, ``page_size``, ``country``,
+        ``created_at__gte``, ``created_at__lte``.
+        """
+        return self._http.request("GET", "/merchant-ledger-entries/", query=params)

alphapay/resources/checkout_sessions.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union
+
+from ..http import Http
+
+
+class CheckoutSessionsResource:
+    """Sessions de checkout à usage unique -- chacune génère sa propre page
+    de paiement hébergée (``checkout_url``), pré-remplie pour un client
+    précis. Contrairement à un lien de paiement réutilisable, une session
+    correspond à UNE tentative de paiement.
+    """
+
+    def __init__(self, http: Http) -> None:
+        self._http = http
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Filtres reconnus : ``page``, ``page_size``, ``search``, ``status``."""
+        return self._http.request("GET", "/checkout-sessions/", query=params)
+
+    def create(
+        self,
+        *,
+        amount: Union[int, float, str],
+        currency: str,
+        customer_email: str,
+        customer_name: str,
+        description: Optional[str] = None,
+        country: Optional[str] = None,
+        customer_phone: Optional[str] = None,
+        return_url: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Union[str, bool, None] = None,
+    ) -> Dict[str, Any]:
+        body = {
+            k: v
+            for k, v in dict(
+                amount=amount,
+                currency=currency,
+                description=description,
+                country=country,
+                customer_email=customer_email,
+                customer_name=customer_name,
+                customer_phone=customer_phone,
+                return_url=return_url,
+                metadata=metadata,
+            ).items()
+            if v is not None
+        }
+        return self._http.request("POST", "/checkout-sessions/", body=body, idempotency_key=idempotency_key)
+
+    def get(self, id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/checkout-sessions/{id}/")
+
+    def cancel(self, id: str) -> Dict[str, Any]:
+        return self._http.request("POST", f"/checkout-sessions/{id}/cancel/")

alphapay/resources/customers.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from ..http import Http
+
+
+class CustomersResource:
+    def __init__(self, http: Http) -> None:
+        self._http = http
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Filtres reconnus : ``page``, ``page_size``, ``search``, ``ordering``."""
+        return self._http.request("GET", "/customers/", query=params)
+
+    def create(
+        self, *, country: str, phone: Optional[str] = None, full_name: Optional[str] = None, email: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """``country`` -- UUID de ``geo.Country`` (ForeignKey côté API), PAS un
+        code ISO2 ("BJ") -- à la différence de ``country`` sur les transactions/
+        paiements. Référentiel pas encore couvert par ce SDK.
+        """
+        body = {k: v for k, v in dict(country=country, phone=phone, full_name=full_name, email=email).items() if v is not None}
+        return self._http.request("POST", "/customers/", body=body)
+
+    def get(self, id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/customers/{id}/")
+
+    def update(self, id: str, **params: Any) -> Dict[str, Any]:
+        return self._http.request("PATCH", f"/customers/{id}/", body=params)
+
+    def delete(self, id: str) -> None:
+        self._http.request("DELETE", f"/customers/{id}/")
+
+    def transactions(self, id: str, **params: Any) -> Dict[str, Any]:
+        """Contrairement à ``TransactionsResource.list()``, cet endpoint EST
+        paginé par page (``page`` fonctionne ici) -- ``CustomerTransactionsView``
+        n'a pas de ``pagination_class`` propre, il retombe donc sur le
+        défaut global (``StandardResultsPagination``), pas
+        ``CreatedAtCursorPagination``.
+        """
+        return self._http.request("GET", f"/customers/{id}/transactions/", query=params)