paywallex 1.0.0__tar.gz

paywallex-1.0.0/LICENSE

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

paywallex-1.0.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: paywallex
+Version: 1.0.0
+Summary: SDK serveur officiel de l'API Paywallex /v1 : sessions de paiement Mobile Money, remboursements, litiges, abonnements, webhooks signés.
+License: MIT
+Project-URL: Homepage, https://paywallex.app/developpeurs
+Project-URL: Source, https://github.com/Paywallex/paywallex-kit/tree/dev/sdk/python
+Keywords: paywallex,paiement,mobile money,orange money,mtn momo,wave,xof
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# paywallex (Python)
+
+SDK serveur officiel de l'API Paywallex `/v1` pour Python 3.9 ou plus récent. Il sert à encaisser par Orange Money, MTN MoMo, Moov Money, Wave ou le solde Paywallex, à rembourser, à suivre les litiges et les abonnements, et à vérifier les webhooks signés.
+
+Aucune dépendance : seule la bibliothèque standard est utilisée.
+
+> Côté serveur uniquement. Ne mettez jamais une clé secrète `pwx_sk_…` dans une page web ou une application mobile.
+
+## Installation
+
+Installez le paquet :
+
+```sh
+pip install paywallex
+```
+
+## Créer une session de paiement
+
+Passez votre clé à la création du client. Une clé `pwx_sk_test_…` vise le bac à sable, une clé `pwx_sk_live_…` vise la production.
+
+Créez une session, puis redirigez le client vers `url` :
+
+```python
+import os
+from paywallex import Paywallex
+
+paywallex = Paywallex(os.environ["PAYWALLEX_KEY"])
+
+session = paywallex.checkout_sessions.create(
+    currency="XOF",
+    line_items=[
+        {"name": "Attiéké poisson", "unit_amount": 2500, "quantity": 2},
+        {"name": "Jus de bissap", "unit_amount": 500},
+    ],
+    success_url="https://maboutique.ci/merci",
+    metadata={"order": "CMD-1042"},
+)
+# session["amount"] == 5500, redirigez vers session["url"]
+```
+
+Les montants sont en XOF entiers : `2500` veut dire 2 500 F.
+
+## Vérifier un webhook
+
+Vérifiez la signature avant de traiter un événement. Le SDK compare en temps constant et refuse un horodatage de plus de 5 minutes.
+
+Passez-lui le corps brut de la requête, pas un dictionnaire déjà décodé :
+
+```python
+from flask import Flask, request
+from paywallex import Webhook, PaywallexError
+
+app = Flask(__name__)
+
+@app.post("/webhooks/paywallex")
+def paywallex_webhook():
+    try:
+        event = Webhook.construct_event(request.get_data(), request.headers.get("Paywallex-Signature"), os.environ["PAYWALLEX_WEBHOOK_SECRET"])
+    except PaywallexError:
+        return "", 400
+    if event["type"] == "checkout_session.completed":
+        pass  # livrer la commande
+    return "", 200
+```
+
+## Les erreurs
+
+Chaque erreur est une `PaywallexError` avec un code stable. Testez le code, jamais le message :
+
+```python
+from paywallex import PaywallexError
+
+try:
+    paywallex.refunds.create(payment=payment_id, amount=1000)
+except PaywallexError as e:
+    if e.code == "refund_not_eligible":
+        ...
+    print(e.status, e.code, e.param, e.request_id)
+```
+
+Passez `language="en"` au client pour recevoir les messages en anglais.
+
+## Nouvelles tentatives et idempotence
+
+Le SDK réessaie 2 fois en cas de coupure réseau, de `429` ou d'erreur `5xx`, en respectant `Retry-After`. Chaque `POST` garde la même clé d'idempotence d'une tentative à l'autre : un paiement ou un remboursement n'est jamais doublé.
+
+Pour rejouer vous-même une requête sans risque, donnez votre propre clé :
+
+```python
+paywallex.refunds.create(payment=payment_id, idempotency_key="remboursement-CMD-1042")
+```
+
+## Ce que couvre le SDK
+
+| Objet | Méthodes |
+| --- | --- |
+| `checkout_sessions` | `create`, `retrieve` |
+| `payments`, `refunds`, `disputes` | `list`, `retrieve`, `all` (toutes les pages) ; `refunds.create` |
+| `payouts`, `events`, `statements` | `list`, `retrieve` |
+| `customers`, `payment_links`, `invoices`, `pots`, `plans`, `coupons`, `subscriptions` | `list`, `create`, `retrieve`, `update`, `action` |
+| `webhook_endpoints` | `list`, `create`, `action("rotate_secret")`, `delete_webhook_endpoint()` |
+| client | `account()`, `balance()`, `network_status()`, `upload_file()`, `add_dispute_evidence()` |
+
+Accepter un litige (rembourser) ou le contester se fait dans le portail Paywallex, jamais par l'API. Un abonnement ou une hausse de prix est toujours accepté par le client dans Paywallex.
+
+## Tests
+
+Lancez les tests (le bac à sable est testé si `PAYWALLEX_TEST_KEY` est défini) :
+
+```sh
+python -m unittest discover tests
+```
+
+## Licence
+
+MIT.

paywallex-1.0.0/README.md

@@ -0,0 +1,116 @@
+# paywallex (Python)
+
+SDK serveur officiel de l'API Paywallex `/v1` pour Python 3.9 ou plus récent. Il sert à encaisser par Orange Money, MTN MoMo, Moov Money, Wave ou le solde Paywallex, à rembourser, à suivre les litiges et les abonnements, et à vérifier les webhooks signés.
+
+Aucune dépendance : seule la bibliothèque standard est utilisée.
+
+> Côté serveur uniquement. Ne mettez jamais une clé secrète `pwx_sk_…` dans une page web ou une application mobile.
+
+## Installation
+
+Installez le paquet :
+
+```sh
+pip install paywallex
+```
+
+## Créer une session de paiement
+
+Passez votre clé à la création du client. Une clé `pwx_sk_test_…` vise le bac à sable, une clé `pwx_sk_live_…` vise la production.
+
+Créez une session, puis redirigez le client vers `url` :
+
+```python
+import os
+from paywallex import Paywallex
+
+paywallex = Paywallex(os.environ["PAYWALLEX_KEY"])
+
+session = paywallex.checkout_sessions.create(
+    currency="XOF",
+    line_items=[
+        {"name": "Attiéké poisson", "unit_amount": 2500, "quantity": 2},
+        {"name": "Jus de bissap", "unit_amount": 500},
+    ],
+    success_url="https://maboutique.ci/merci",
+    metadata={"order": "CMD-1042"},
+)
+# session["amount"] == 5500, redirigez vers session["url"]
+```
+
+Les montants sont en XOF entiers : `2500` veut dire 2 500 F.
+
+## Vérifier un webhook
+
+Vérifiez la signature avant de traiter un événement. Le SDK compare en temps constant et refuse un horodatage de plus de 5 minutes.
+
+Passez-lui le corps brut de la requête, pas un dictionnaire déjà décodé :
+
+```python
+from flask import Flask, request
+from paywallex import Webhook, PaywallexError
+
+app = Flask(__name__)
+
+@app.post("/webhooks/paywallex")
+def paywallex_webhook():
+    try:
+        event = Webhook.construct_event(request.get_data(), request.headers.get("Paywallex-Signature"), os.environ["PAYWALLEX_WEBHOOK_SECRET"])
+    except PaywallexError:
+        return "", 400
+    if event["type"] == "checkout_session.completed":
+        pass  # livrer la commande
+    return "", 200
+```
+
+## Les erreurs
+
+Chaque erreur est une `PaywallexError` avec un code stable. Testez le code, jamais le message :
+
+```python
+from paywallex import PaywallexError
+
+try:
+    paywallex.refunds.create(payment=payment_id, amount=1000)
+except PaywallexError as e:
+    if e.code == "refund_not_eligible":
+        ...
+    print(e.status, e.code, e.param, e.request_id)
+```
+
+Passez `language="en"` au client pour recevoir les messages en anglais.
+
+## Nouvelles tentatives et idempotence
+
+Le SDK réessaie 2 fois en cas de coupure réseau, de `429` ou d'erreur `5xx`, en respectant `Retry-After`. Chaque `POST` garde la même clé d'idempotence d'une tentative à l'autre : un paiement ou un remboursement n'est jamais doublé.
+
+Pour rejouer vous-même une requête sans risque, donnez votre propre clé :
+
+```python
+paywallex.refunds.create(payment=payment_id, idempotency_key="remboursement-CMD-1042")
+```
+
+## Ce que couvre le SDK
+
+| Objet | Méthodes |
+| --- | --- |
+| `checkout_sessions` | `create`, `retrieve` |
+| `payments`, `refunds`, `disputes` | `list`, `retrieve`, `all` (toutes les pages) ; `refunds.create` |
+| `payouts`, `events`, `statements` | `list`, `retrieve` |
+| `customers`, `payment_links`, `invoices`, `pots`, `plans`, `coupons`, `subscriptions` | `list`, `create`, `retrieve`, `update`, `action` |
+| `webhook_endpoints` | `list`, `create`, `action("rotate_secret")`, `delete_webhook_endpoint()` |
+| client | `account()`, `balance()`, `network_status()`, `upload_file()`, `add_dispute_evidence()` |
+
+Accepter un litige (rembourser) ou le contester se fait dans le portail Paywallex, jamais par l'API. Un abonnement ou une hausse de prix est toujours accepté par le client dans Paywallex.
+
+## Tests
+
+Lancez les tests (le bac à sable est testé si `PAYWALLEX_TEST_KEY` est défini) :
+
+```sh
+python -m unittest discover tests
+```
+
+## Licence
+
+MIT.

paywallex-1.0.0/paywallex/__init__.py

@@ -0,0 +1,183 @@
+"""SDK serveur officiel de l'API Paywallex /v1 (Python 3.9+, sans dépendance).
+
+Côté serveur uniquement : ne mettez jamais une clé secrète pwx_sk_… dans une page web ou une app mobile.
+Signé : Superagent (DV3, 24 oct. 2026).
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+
+__version__ = "1.0.0"
+__all__ = ["Paywallex", "PaywallexError", "Webhook", "__version__"]
+
+Transport = Callable[[str, str, Dict[str, str], Optional[bytes]], Tuple[int, Dict[str, str], bytes]]
+
+
+class PaywallexError(Exception):
+    """Erreur de l'API : testez ``code`` (stable), jamais le message."""
+
+    def __init__(self, message: str, status: int, code: str, param: Optional[str] = None, request_id: Optional[str] = None):
+        super().__init__(message)
+        self.message, self.status, self.code, self.param, self.request_id = message, status, code, param, request_id
+
+
+class Webhook:
+    @staticmethod
+    def construct_event(raw_body: bytes | str, signature_header: Optional[str], secret: str, tolerance_seconds: int = 300) -> Dict[str, Any]:
+        """Vérifie l'en-tête Paywallex-Signature (t=…,v1=…). Passez le corps BRUT, jamais un dict déjà décodé."""
+        m = re.fullmatch(r"t=([0-9]+),v1=([a-f0-9]{64})", (signature_header or "").strip())
+        if not m:
+            raise PaywallexError("Signature absente ou mal formée.", 400, "invalid_signature")
+        if abs(time.time() - int(m.group(1))) > tolerance_seconds:
+            raise PaywallexError("Signature expirée.", 400, "signature_expired")
+        body = raw_body.decode("utf-8") if isinstance(raw_body, bytes) else raw_body
+        expected = hmac.new(secret.encode(), f"{m.group(1)}.{body}".encode(), hashlib.sha256).hexdigest()
+        if not hmac.compare_digest(expected, m.group(2)):
+            raise PaywallexError("Signature invalide.", 400, "invalid_signature")
+        return json.loads(body)
+
+
+class Service:
+    """Un objet de l'API (/v1/<chemin>) : list, create, retrieve, update, action, all."""
+
+    def __init__(self, client: "Paywallex", path: str, actions: Tuple[str, ...] = ()):
+        self._c, self._path, self._actions = client, path, actions
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        return self._c.request("GET", f"/v1/{self._path}", params)
+
+    def create(self, idempotency_key: Optional[str] = None, **params: Any) -> Dict[str, Any]:
+        return self._c.request("POST", f"/v1/{self._path}", params, idempotency_key)
+
+    def retrieve(self, id: str) -> Dict[str, Any]:
+        return self._c.request("GET", f"/v1/{self._path}/{urllib.parse.quote(id, safe='')}")
+
+    def update(self, id: str, idempotency_key: Optional[str] = None, **params: Any) -> Dict[str, Any]:
+        return self._c.request("POST", f"/v1/{self._path}/{urllib.parse.quote(id, safe='')}", params, idempotency_key)
+
+    def action(self, id: str, action: str, idempotency_key: Optional[str] = None, **params: Any) -> Dict[str, Any]:
+        if action not in self._actions:
+            raise PaywallexError(f"Action inconnue : {action}. Possibles : {', '.join(self._actions)}.", 0, "configuration_error")
+        return self._c.request("POST", f"/v1/{self._path}/{urllib.parse.quote(id, safe='')}/{action}", params, idempotency_key)
+
+    def all(self, **params: Any) -> Iterator[Dict[str, Any]]:
+        """Parcourt toutes les pages : for p in client.payments.all(): …"""
+        after = None
+        for _ in range(10000):
+            page = self.list(**params, **({"starting_after": after} if after else {}))
+            data = page.get("data") or []
+            yield from data
+            if not page.get("has_more") or not data:
+                return
+            after = data[-1]["id"]
+
+
+_SERVICES = {
+    "checkout_sessions": ("checkout_sessions", ()), "payments": ("payments", ()), "refunds": ("refunds", ()),
+    "disputes": ("disputes", ()), "payouts": ("payouts", ()), "events": ("events", ()),
+    "customers": ("customers", ("archive",)), "payment_links": ("payment_links", ("cancel",)),
+    "invoices": ("invoices", ("issue", "cancel")), "pots": ("pots", ("close", "cancel")), "statements": ("statements", ()),
+    "plans": ("plans", ()), "coupons": ("coupons", ("archive",)),
+    "subscriptions": ("subscriptions", ("cancel", "pause", "resume", "change_plan", "manage_link")),
+    "webhook_endpoints": ("webhook_endpoints", ("rotate_secret",)),
+}
+
+
+class Paywallex:
+    """Client de l'API /v1. Passez votre clé explicitement : pwx_sk_test_… (bac à sable) ou pwx_sk_live_… (production)."""
+
+    checkout_sessions: Service; payments: Service; refunds: Service; disputes: Service; payouts: Service; events: Service
+    customers: Service; payment_links: Service; invoices: Service; pots: Service; statements: Service
+    plans: Service; coupons: Service; subscriptions: Service; webhook_endpoints: Service
+
+    def __init__(self, api_key: str, *, base_url: str = "https://api.paywallex.app", timeout: float = 30, max_retries: int = 2,
+                 language: str = "fr", transport: Optional[Transport] = None):
+        if not api_key:
+            raise PaywallexError("Clé manquante : passez votre clé secrète pwx_sk_… explicitement.", 0, "configuration_error")
+        self._key, self._base, self._timeout, self._retries, self._lang = api_key, base_url.rstrip("/"), timeout, max_retries, language
+        self._transport = transport or self._urllib
+        for attr, (path, actions) in _SERVICES.items():
+            setattr(self, attr, Service(self, path, actions))
+
+    def account(self) -> Dict[str, Any]:
+        return self.request("GET", "/v1/account")
+
+    def balance(self) -> Dict[str, Any]:
+        return self.request("GET", "/v1/balance")
+
+    def network_status(self) -> Dict[str, Any]:
+        """Réseaux Mobile Money du pays : masquez ceux qui sont « unavailable » avant le paiement."""
+        return self.request("GET", "/v1/network_status")
+
+    def add_dispute_evidence(self, dispute_id: str, text: str, files: Optional[List[str]] = None, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        return self.request("POST", f"/v1/disputes/{urllib.parse.quote(dispute_id, safe='')}/evidence",
+                            {"text": text, **({"files": files} if files else {})}, idempotency_key)
+
+    def upload_file(self, name: str, content_type: str, data: bytes) -> Dict[str, Any]:
+        """Dépose un justificatif PDF, PNG ou JPEG (5 Mo max) et renvoie son id."""
+        f = self.request("POST", "/v1/files", {"name": name, "content_type": content_type, "size": len(data)})
+        status, _, _ = self._transport("PUT", f["upload_url"], {"Content-Type": content_type}, data)
+        if not 200 <= status < 300:
+            raise PaywallexError(f"Dépôt du fichier refusé ({status}).", status, "file_upload_failed")
+        return f
+
+    def delete_webhook_endpoint(self, id: str) -> Dict[str, Any]:
+        return self.request("DELETE", f"/v1/webhook_endpoints/{urllib.parse.quote(id, safe='')}")
+
+    def request(self, method: str, path: str, params: Optional[Dict[str, Any]] = None, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        params = {k: v for k, v in (params or {}).items() if v is not None}
+        url, body = self._base + path, None
+        if method == "GET" and params:
+            url += "?" + urllib.parse.urlencode({k: (str(v).lower() if isinstance(v, bool) else v) for k, v in params.items()})
+        elif method != "GET":
+            body = json.dumps(params, ensure_ascii=False).encode("utf-8")
+        # Une seule clé d'idempotence pour toutes les tentatives : un POST rejoué n'est jamais doublé.
+        idem = (idempotency_key or str(uuid.uuid4())) if method == "POST" else None
+        headers = {"Authorization": f"Bearer {self._key}", "Accept-Language": self._lang,
+                   "User-Agent": f"paywallex-python/{__version__}", "Paywallex-Sdk": f"python/{__version__}"}
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        if idem:
+            headers["Idempotency-Key"] = idem
+        attempt = 0
+        while True:
+            try:
+                status, res_headers, raw = self._transport(method, url, headers, body)
+            except OSError as e:
+                if attempt < self._retries:
+                    time.sleep(0.5 * 2 ** attempt); attempt += 1; continue
+                raise PaywallexError(f"Paywallex injoignable : {e}", 0, "network_error") from e
+            try:
+                data = json.loads(raw.decode("utf-8")) if raw else {}
+            except ValueError:
+                data = {}
+            if not isinstance(data, dict):
+                data = {}
+            if 200 <= status < 300:
+                return data
+            if (status == 429 or status >= 500) and attempt < self._retries:
+                try:
+                    ra = float(res_headers.get("retry-after", "0"))
+                except ValueError:
+                    ra = 0
+                time.sleep(min(ra, 30) if ra > 0 else 0.5 * 2 ** attempt); attempt += 1; continue
+            err = data.get("error") if isinstance(data.get("error"), dict) else {}
+            raise PaywallexError(err.get("message") or f"Requête refusée ({status}).", status, err.get("code") or "unknown_error",
+                                 err.get("param"), err.get("request_id") or res_headers.get("request-id"))
+
+    def _urllib(self, method: str, url: str, headers: Dict[str, str], body: Optional[bytes]) -> Tuple[int, Dict[str, str], bytes]:
+        req = urllib.request.Request(url, data=body, method=method, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as r:
+                return r.status, {k.lower(): v for k, v in r.headers.items()}, r.read()
+        except urllib.error.HTTPError as e:
+            return e.code, {k.lower(): v for k, v in (e.headers or {}).items()}, e.read()

paywallex-1.0.0/paywallex.egg-info/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: paywallex
+Version: 1.0.0
+Summary: SDK serveur officiel de l'API Paywallex /v1 : sessions de paiement Mobile Money, remboursements, litiges, abonnements, webhooks signés.
+License: MIT
+Project-URL: Homepage, https://paywallex.app/developpeurs
+Project-URL: Source, https://github.com/Paywallex/paywallex-kit/tree/dev/sdk/python
+Keywords: paywallex,paiement,mobile money,orange money,mtn momo,wave,xof
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# paywallex (Python)
+
+SDK serveur officiel de l'API Paywallex `/v1` pour Python 3.9 ou plus récent. Il sert à encaisser par Orange Money, MTN MoMo, Moov Money, Wave ou le solde Paywallex, à rembourser, à suivre les litiges et les abonnements, et à vérifier les webhooks signés.
+
+Aucune dépendance : seule la bibliothèque standard est utilisée.
+
+> Côté serveur uniquement. Ne mettez jamais une clé secrète `pwx_sk_…` dans une page web ou une application mobile.
+
+## Installation
+
+Installez le paquet :
+
+```sh
+pip install paywallex
+```
+
+## Créer une session de paiement
+
+Passez votre clé à la création du client. Une clé `pwx_sk_test_…` vise le bac à sable, une clé `pwx_sk_live_…` vise la production.
+
+Créez une session, puis redirigez le client vers `url` :
+
+```python
+import os
+from paywallex import Paywallex
+
+paywallex = Paywallex(os.environ["PAYWALLEX_KEY"])
+
+session = paywallex.checkout_sessions.create(
+    currency="XOF",
+    line_items=[
+        {"name": "Attiéké poisson", "unit_amount": 2500, "quantity": 2},
+        {"name": "Jus de bissap", "unit_amount": 500},
+    ],
+    success_url="https://maboutique.ci/merci",
+    metadata={"order": "CMD-1042"},
+)
+# session["amount"] == 5500, redirigez vers session["url"]
+```
+
+Les montants sont en XOF entiers : `2500` veut dire 2 500 F.
+
+## Vérifier un webhook
+
+Vérifiez la signature avant de traiter un événement. Le SDK compare en temps constant et refuse un horodatage de plus de 5 minutes.
+
+Passez-lui le corps brut de la requête, pas un dictionnaire déjà décodé :
+
+```python
+from flask import Flask, request
+from paywallex import Webhook, PaywallexError
+
+app = Flask(__name__)
+
+@app.post("/webhooks/paywallex")
+def paywallex_webhook():
+    try:
+        event = Webhook.construct_event(request.get_data(), request.headers.get("Paywallex-Signature"), os.environ["PAYWALLEX_WEBHOOK_SECRET"])
+    except PaywallexError:
+        return "", 400
+    if event["type"] == "checkout_session.completed":
+        pass  # livrer la commande
+    return "", 200
+```
+
+## Les erreurs
+
+Chaque erreur est une `PaywallexError` avec un code stable. Testez le code, jamais le message :
+
+```python
+from paywallex import PaywallexError
+
+try:
+    paywallex.refunds.create(payment=payment_id, amount=1000)
+except PaywallexError as e:
+    if e.code == "refund_not_eligible":
+        ...
+    print(e.status, e.code, e.param, e.request_id)
+```
+
+Passez `language="en"` au client pour recevoir les messages en anglais.
+
+## Nouvelles tentatives et idempotence
+
+Le SDK réessaie 2 fois en cas de coupure réseau, de `429` ou d'erreur `5xx`, en respectant `Retry-After`. Chaque `POST` garde la même clé d'idempotence d'une tentative à l'autre : un paiement ou un remboursement n'est jamais doublé.
+
+Pour rejouer vous-même une requête sans risque, donnez votre propre clé :
+
+```python
+paywallex.refunds.create(payment=payment_id, idempotency_key="remboursement-CMD-1042")
+```
+
+## Ce que couvre le SDK
+
+| Objet | Méthodes |
+| --- | --- |
+| `checkout_sessions` | `create`, `retrieve` |
+| `payments`, `refunds`, `disputes` | `list`, `retrieve`, `all` (toutes les pages) ; `refunds.create` |
+| `payouts`, `events`, `statements` | `list`, `retrieve` |
+| `customers`, `payment_links`, `invoices`, `pots`, `plans`, `coupons`, `subscriptions` | `list`, `create`, `retrieve`, `update`, `action` |
+| `webhook_endpoints` | `list`, `create`, `action("rotate_secret")`, `delete_webhook_endpoint()` |
+| client | `account()`, `balance()`, `network_status()`, `upload_file()`, `add_dispute_evidence()` |
+
+Accepter un litige (rembourser) ou le contester se fait dans le portail Paywallex, jamais par l'API. Un abonnement ou une hausse de prix est toujours accepté par le client dans Paywallex.
+
+## Tests
+
+Lancez les tests (le bac à sable est testé si `PAYWALLEX_TEST_KEY` est défini) :
+
+```sh
+python -m unittest discover tests
+```
+
+## Licence
+
+MIT.

paywallex-1.0.0/paywallex.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+paywallex/__init__.py
+paywallex.egg-info/PKG-INFO
+paywallex.egg-info/SOURCES.txt
+paywallex.egg-info/dependency_links.txt
+paywallex.egg-info/top_level.txt
+tests/test_paywallex.py

paywallex-1.0.0/paywallex.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

paywallex-1.0.0/paywallex.egg-info/top_level.txt

@@ -0,0 +1 @@
+paywallex

paywallex-1.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "paywallex"
+version = "1.0.0"
+description = "SDK serveur officiel de l'API Paywallex /v1 : sessions de paiement Mobile Money, remboursements, litiges, abonnements, webhooks signés."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+keywords = ["paywallex", "paiement", "mobile money", "orange money", "mtn momo", "wave", "xof"]
+classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent"]
+
+[project.urls]
+Homepage = "https://paywallex.app/developpeurs"
+Source = "https://github.com/Paywallex/paywallex-kit/tree/dev/sdk/python"
+
+[tool.setuptools]
+packages = ["paywallex"]

paywallex-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

paywallex-1.0.0/tests/test_paywallex.py

@@ -0,0 +1,77 @@
+"""Tests du SDK Python : sans réseau, puis bac à sable si PAYWALLEX_TEST_KEY est défini. Signé : Superagent."""
+import hashlib, hmac, json, os, sys, time, unittest
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from paywallex import Paywallex, PaywallexError, Webhook  # noqa: E402
+
+def sign(body, secret, t=None):
+    t = t or int(time.time())
+    return f"t={t},v1=" + hmac.new(secret.encode(), f"{t}.{body}".encode(), hashlib.sha256).hexdigest()
+
+class Offline(unittest.TestCase):
+    def test_webhook(self):
+        b = json.dumps({"id": "evt_1", "type": "payment.succeeded"})
+        self.assertEqual(Webhook.construct_event(b, sign(b, "k"), "k")["type"], "payment.succeeded")
+        self.assertEqual(Webhook.construct_event(b.encode(), sign(b, "k"), "k")["id"], "evt_1")
+        for hdr, code in [(sign(b, "x"), "invalid_signature"), (sign(b, "k", 1000), "signature_expired"), (None, "invalid_signature")]:
+            with self.assertRaises(PaywallexError) as c: Webhook.construct_event(b, hdr, "k")
+            self.assertEqual(c.exception.code, code)
+
+    def test_retry_same_idempotency_key(self):
+        keys, n = [], [0]
+        def t(m, u, h, b):
+            keys.append(h["Idempotency-Key"]); n[0] += 1
+            return (503, {}, b"{}") if n[0] == 1 else (201, {}, json.dumps({"id": "cs_1", "url": "u"}).encode())
+        p = Paywallex("pwx_sk_test_x", transport=t)
+        self.assertEqual(p.checkout_sessions.create(currency="XOF", amount=1000)["id"], "cs_1")
+        self.assertEqual(n[0], 2); self.assertEqual(keys[0], keys[1])
+
+    def test_error_fields(self):
+        t = lambda *a: (400, {}, json.dumps({"error": {"code": "parameter_invalid", "message": "Invalid parameter: amount.", "param": "amount", "request_id": "req_1"}}).encode())
+        with self.assertRaises(PaywallexError) as c: Paywallex("k", transport=t).refunds.create(payment="x")
+        e = c.exception; self.assertEqual((e.code, e.param, e.request_id, e.status), ("parameter_invalid", "amount", "req_1", 400))
+
+    def test_headers_and_url(self):
+        with self.assertRaises(PaywallexError): Paywallex("")
+        seen = {}
+        def t(m, u, h, b): seen.update(m=m, u=u, h=h); return 200, {}, b'{"object":"network_status","data":[]}'
+        Paywallex("pwx_sk_test_x", base_url="https://api.paywallx.xyz/", language="en", transport=t).network_status()
+        self.assertEqual(seen["u"], "https://api.paywallx.xyz/v1/network_status"); self.assertEqual(seen["h"]["Accept-Language"], "en")
+        self.assertNotIn("Idempotency-Key", seen["h"]); self.assertTrue(seen["h"]["User-Agent"].startswith("paywallex-python/1."))
+
+    def test_pagination(self):
+        urls = []
+        def t(m, u, h, b):
+            urls.append(u)
+            d = {"data": [{"id": "p3"}], "has_more": False} if "starting_after=p2" in u else {"data": [{"id": "p1"}, {"id": "p2"}], "has_more": True}
+            return 200, {}, json.dumps(d).encode()
+        self.assertEqual([x["id"] for x in Paywallex("k", transport=t).payments.all(limit=2)], ["p1", "p2", "p3"]); self.assertEqual(len(urls), 2)
+
+    def test_unknown_action(self):
+        with self.assertRaises(PaywallexError) as c: Paywallex("k").invoices.action("x", "delete")
+        self.assertEqual(c.exception.code, "configuration_error")
+
+KEY, BASE = os.environ.get("PAYWALLEX_TEST_KEY"), os.environ.get("PAYWALLEX_BASE_URL", "https://api.paywallex.app")
+
+@unittest.skipUnless(KEY, "PAYWALLEX_TEST_KEY absent")
+class Sandbox(unittest.TestCase):
+    def test_reads_and_errors(self):
+        p = Paywallex(KEY, base_url=BASE)
+        self.assertEqual(p.network_status()["object"], "network_status"); self.assertTrue(p.account()["id"])
+        for i, _ in enumerate(p.payments.all(limit=2)):
+            if i >= 2: break
+        with self.assertRaises(PaywallexError) as c:
+            p.checkout_sessions.create(currency="XOF", amount=1000, line_items=[{"name": "x", "unit_amount": 500}])
+        self.assertEqual((c.exception.code, c.exception.param), ("amount_mismatch", "amount"))
+        with self.assertRaises(PaywallexError) as c: Paywallex(KEY, base_url=BASE, language="en").disputes.retrieve("x")
+        self.assertEqual((c.exception.code, c.exception.message), ("resource_missing", "No such resource."))
+
+    def test_checkout_with_cart(self):
+        try:
+            s = Paywallex(KEY, base_url=BASE).checkout_sessions.create(currency="XOF", line_items=[{"name": "Garba", "unit_amount": 1500, "quantity": 2}])
+        except PaywallexError as e:
+            if e.code == "review_demo_blocked": self.skipTest("clé d'un compte de démonstration : création bloquée")
+            raise
+        self.assertEqual(s["amount"], 3000)
+
+if __name__ == "__main__":
+    unittest.main()