shwary-python 1.0.1__tar.gz

shwary_python-1.0.1/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

shwary_python-1.0.1/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: shwary-python
+Version: 1.0.1
+Summary: SDK Python moderne (Async/Sync) pour l'API de paiement Shwary.
+Author-email: Josué Luis Panzu <josuepanzu8@gmail.com>
+License: MIT
+Keywords: africa,fintech,kenya,mobile-money,payment,rdc,shwary,uganda
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: phonenumbers>=9.0.22
+Requires-Dist: pydantic>=2.12.5
+Description-Content-Type: text/markdown
+
+# Shwary Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/shwary-python.svg)](https://pypi.org/project/shwary-python/)
+[![Python versions](https://img.shields.io/pypi/pyversions/shwary-python.svg)](https://pypi.org/project/shwary-python/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Shwary Python** est une bibliothèque cliente moderne, asynchrone et performante (non officielle)  pour l'intégration de l'API [Shwary](https://shwary.com). Elle permet d'initier des paiements Mobile Money en **RDC**, au **Kenya** et en **Ouganda** avec une validation stricte des données avant l'envoi.
+
+
+
+## Caractéristiques
+
+* **Gestion d'erreurs native** : Pas besoin de vérifier les `status_code` manuellement. Le SDK lève des exceptions explicites (`AuthenticationError`, `ValidationError`, etc.).
+* **Async-first** : Construit sur `httpx` pour des performances optimales (Pooling de connexions).
+* **Dual-mode** : Support complet des modes Synchrone et Asynchrone.
+* **Validation Robuste** : Vérification des numéros (E.164) et des montants minimums (ex: 2900 CDF pour la RDC).
+* **Type-safe** : Basé sur Pydantic V2 pour une autocomplétion parfaite dans votre IDE.
+* **Ultra-rapide** : Optimisé avec `uv` et `__slots__` pour minimiser l'empreinte mémoire.
+
+## Installation
+
+Avec `uv` (recommandé) :
+```bash
+uv add shwary-python
+```
+Ou avec `pip`
+```bash
+pip install shwary-python
+```
+
+## Utilisation Rapide
+### Initier un paiement (Async)
+Le SDK gère les erreurs pour vous. Enveloppez simplement votre appel dans un bloc `try...except`.
+
+```python
+import asyncio
+from shwary import ShwaryAsync
+
+async def main():
+    async with ShwaryAsync(
+        merchant_id="votre-uuid",
+        merchant_key="votre-cle-secrete",
+        is_sandbox=True
+    ) as client:
+        try:
+            # Le SDK lève une exception si l'API répond avec une erreur
+            payment = await client.initiate_payment(
+                country="DRC",
+                amount=5000,
+                phone_number="+243972345678",
+                callback_url="[https://votre-site.com/webhooks/shwary](https://votre-site.com/webhooks/shwary)"
+            )
+            print(f"ID Transaction: {payment['id']}")
+        except Exception as e:
+            print(f"Le paiement a échoué: {e}")
+
+asyncio.run(main())
+```
+
+### Initier un paiement (Sync)
+```python
+from shwary import Shwary
+
+with Shwary(merchant_id="...", merchant_key="...", is_sandbox=False) as client:
+    response = client.initiate_payment(
+        country="KE",
+        amount=150.5,
+        phone_number="+254700000000"
+    )
+```
+
+## Vérifier une transaction
+Si vous n'avez pas reçu de webhook ou souhaitez vérifier le statut actuel :
+
+```python
+# Mode Synchrone
+from shwary import Shwary
+
+with Shwary(merchant_id="...", merchant_key="...") as client:
+    tx = client.get_transaction("votre-id-transaction")
+    print(f"Statut actuel : {tx['status']}")
+```
+
+## Validation par pays
+Le SDK applique les règles métiers de Shwary localement pour économiser des appels réseau :
+
+| Pays | Code | Devise | Montant Min. |
+| :--- | :--- | :--- | :--- |
+| RDC | DRC | CDF | 2900 |
+| Kenya | KE | KES | > 0 |
+| Ouganda | UG | UGX | > 0 |
+
+## Gestion des Webhooks (Callbacks)
+Lorsque le statut d'un paiement change (ex: pending -> completed), Shwary envoie un POST JSON à votre callbackUrl. Voici comment traiter la charge utile avec les modèles du SDK (exemple FastAPI) :
+
+```python
+from fastapi import FastAPI, Request
+
+app = FastAPI()
+
+@app.post("/webhooks/shwary")
+async def shwary_webhook(data: dict):
+    # Shwary envoie le même format que la réponse initiate_payment
+    status = data.get("status")
+    transaction_id = data.get("id")
+    
+    if status == "completed":
+        # Livrez votre service ici
+        pass
+    
+    return {"status": "ok"}
+```
+
+## Gestion des Erreurs
+Le SDK transforme les erreurs HTTP en exceptions Python. Vous n'avez pas besoin de vérifier manuellement les codes de statut, gérez simplement les exceptions :
+
+| Exception | Cause |
+| :--- | :--- |
+| **ValidationError** | Données invalides (ex: montant < 2900 CDF en RDC, numéro mal formé). |
+| **AuthenticationError** | Identifiants `merchant_id` ou `merchant_key` incorrects. |
+| **ShwaryAPIError** | Erreur côté serveur Shwary ou problème réseau. |
+| **ShwaryError** | Classe de base pour toutes les exceptions du SDK. |
+
+
+```python
+from shwary.exceptions import ValidationError, AuthenticationError, ShwaryAPIError
+
+try:
+    client.initiate_payment(...)
+except ValidationError as e:
+    # Erreur de format téléphone ou montant insuffisant
+    print(f"Données invalides : {e}")
+except AuthenticationError:
+    # Identifiants merchant_id / merchant_key invalides
+    print("Erreur d'authentification Shwary")
+except ShwaryAPIError as e:
+    # Autres erreurs API (404, 500, etc.)
+    print(f"Erreur API {e.status_code}: {e.message}")
+```
+
+## Développement
+
+Pour contribuer au SDK :
+
+    1. Installez uv : curl -LsSf https://astral.sh/uv/install.sh | sh
+
+    2. Installez les dépendances : uv sync
+
+    3. Lancez les tests : uv run pytest
+
+### Licence
+
+Distribué sous la licence MIT. Voir [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) pour plus d'informations.

shwary_python-1.0.1/README.md

@@ -0,0 +1,153 @@
+# Shwary Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/shwary-python.svg)](https://pypi.org/project/shwary-python/)
+[![Python versions](https://img.shields.io/pypi/pyversions/shwary-python.svg)](https://pypi.org/project/shwary-python/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Shwary Python** est une bibliothèque cliente moderne, asynchrone et performante (non officielle)  pour l'intégration de l'API [Shwary](https://shwary.com). Elle permet d'initier des paiements Mobile Money en **RDC**, au **Kenya** et en **Ouganda** avec une validation stricte des données avant l'envoi.
+
+
+
+## Caractéristiques
+
+* **Gestion d'erreurs native** : Pas besoin de vérifier les `status_code` manuellement. Le SDK lève des exceptions explicites (`AuthenticationError`, `ValidationError`, etc.).
+* **Async-first** : Construit sur `httpx` pour des performances optimales (Pooling de connexions).
+* **Dual-mode** : Support complet des modes Synchrone et Asynchrone.
+* **Validation Robuste** : Vérification des numéros (E.164) et des montants minimums (ex: 2900 CDF pour la RDC).
+* **Type-safe** : Basé sur Pydantic V2 pour une autocomplétion parfaite dans votre IDE.
+* **Ultra-rapide** : Optimisé avec `uv` et `__slots__` pour minimiser l'empreinte mémoire.
+
+## Installation
+
+Avec `uv` (recommandé) :
+```bash
+uv add shwary-python
+```
+Ou avec `pip`
+```bash
+pip install shwary-python
+```
+
+## Utilisation Rapide
+### Initier un paiement (Async)
+Le SDK gère les erreurs pour vous. Enveloppez simplement votre appel dans un bloc `try...except`.
+
+```python
+import asyncio
+from shwary import ShwaryAsync
+
+async def main():
+    async with ShwaryAsync(
+        merchant_id="votre-uuid",
+        merchant_key="votre-cle-secrete",
+        is_sandbox=True
+    ) as client:
+        try:
+            # Le SDK lève une exception si l'API répond avec une erreur
+            payment = await client.initiate_payment(
+                country="DRC",
+                amount=5000,
+                phone_number="+243972345678",
+                callback_url="[https://votre-site.com/webhooks/shwary](https://votre-site.com/webhooks/shwary)"
+            )
+            print(f"ID Transaction: {payment['id']}")
+        except Exception as e:
+            print(f"Le paiement a échoué: {e}")
+
+asyncio.run(main())
+```
+
+### Initier un paiement (Sync)
+```python
+from shwary import Shwary
+
+with Shwary(merchant_id="...", merchant_key="...", is_sandbox=False) as client:
+    response = client.initiate_payment(
+        country="KE",
+        amount=150.5,
+        phone_number="+254700000000"
+    )
+```
+
+## Vérifier une transaction
+Si vous n'avez pas reçu de webhook ou souhaitez vérifier le statut actuel :
+
+```python
+# Mode Synchrone
+from shwary import Shwary
+
+with Shwary(merchant_id="...", merchant_key="...") as client:
+    tx = client.get_transaction("votre-id-transaction")
+    print(f"Statut actuel : {tx['status']}")
+```
+
+## Validation par pays
+Le SDK applique les règles métiers de Shwary localement pour économiser des appels réseau :
+
+| Pays | Code | Devise | Montant Min. |
+| :--- | :--- | :--- | :--- |
+| RDC | DRC | CDF | 2900 |
+| Kenya | KE | KES | > 0 |
+| Ouganda | UG | UGX | > 0 |
+
+## Gestion des Webhooks (Callbacks)
+Lorsque le statut d'un paiement change (ex: pending -> completed), Shwary envoie un POST JSON à votre callbackUrl. Voici comment traiter la charge utile avec les modèles du SDK (exemple FastAPI) :
+
+```python
+from fastapi import FastAPI, Request
+
+app = FastAPI()
+
+@app.post("/webhooks/shwary")
+async def shwary_webhook(data: dict):
+    # Shwary envoie le même format que la réponse initiate_payment
+    status = data.get("status")
+    transaction_id = data.get("id")
+    
+    if status == "completed":
+        # Livrez votre service ici
+        pass
+    
+    return {"status": "ok"}
+```
+
+## Gestion des Erreurs
+Le SDK transforme les erreurs HTTP en exceptions Python. Vous n'avez pas besoin de vérifier manuellement les codes de statut, gérez simplement les exceptions :
+
+| Exception | Cause |
+| :--- | :--- |
+| **ValidationError** | Données invalides (ex: montant < 2900 CDF en RDC, numéro mal formé). |
+| **AuthenticationError** | Identifiants `merchant_id` ou `merchant_key` incorrects. |
+| **ShwaryAPIError** | Erreur côté serveur Shwary ou problème réseau. |
+| **ShwaryError** | Classe de base pour toutes les exceptions du SDK. |
+
+
+```python
+from shwary.exceptions import ValidationError, AuthenticationError, ShwaryAPIError
+
+try:
+    client.initiate_payment(...)
+except ValidationError as e:
+    # Erreur de format téléphone ou montant insuffisant
+    print(f"Données invalides : {e}")
+except AuthenticationError:
+    # Identifiants merchant_id / merchant_key invalides
+    print("Erreur d'authentification Shwary")
+except ShwaryAPIError as e:
+    # Autres erreurs API (404, 500, etc.)
+    print(f"Erreur API {e.status_code}: {e.message}")
+```
+
+## Développement
+
+Pour contribuer au SDK :
+
+    1. Installez uv : curl -LsSf https://astral.sh/uv/install.sh | sh
+
+    2. Installez les dépendances : uv sync
+
+    3. Lancez les tests : uv run pytest
+
+### Licence
+
+Distribué sous la licence MIT. Voir [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) pour plus d'informations.

shwary_python-1.0.1/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "shwary-python"
+version = "1.0.1"
+description = "SDK Python moderne (Async/Sync) pour l'API de paiement Shwary."
+readme = "README.md"
+authors = [
+    { name = "Josué Luis Panzu", email = "josuepanzu8@gmail.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "httpx>=0.28.1",
+    "phonenumbers>=9.0.22",
+    "pydantic>=2.12.5",
+]
+license = { text = "MIT" }
+keywords = ["shwary", "fintech", "payment", "mobile-money", "africa", "rdc", "kenya", "uganda"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "pytest-mock>=3.15.1",
+    "respx>=0.22.0",
+    "ruff>=0.14.14",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 88
+select = ["E", "F", "I"] # Erreurs, Flakes, et tris d'Imports
+
+[tool.hatch.build.targets.sdist]
+packages = ["src/shwary"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/shwary"]

shwary_python-1.0.1/shwary/__init__.py

@@ -0,0 +1,4 @@
+from .clients import Shwary, ShwaryAsync
+from .exceptions import ShwaryError, ValidationError, AuthenticationError, ShwaryAPIError
+
+__all__ = ["Shwary", "ShwaryAsync", "ShwaryError", "ValidationError", "AuthenticationError", "ShwaryAPIError"]

shwary_python-1.0.1/shwary/clients/__init__.py

@@ -0,0 +1,4 @@
+from .async_client import ShwaryAsync
+from .sync import Shwary
+
+__all__ = ("Shwary", "ShwaryAsync")

shwary_python-1.0.1/shwary/clients/async_client.py

@@ -0,0 +1,59 @@
+import httpx
+from ..core import prepare_payment_request
+from ..exceptions import raise_from_response
+
+
+class ShwaryAsync:
+    """
+    Client asynchrone haute performance pour l'API Shwary.
+    Doit être utilisé comme context manager ou fermé manuellement.
+    """
+    __slots__ = ('merchant_id', 'merchant_key', 'is_sandbox', '_client', '_base_url')
+
+    def __init__(self, merchant_id: str, merchant_key: str, is_sandbox: bool = False, timeout: float = 30.0):
+        self.is_sandbox = is_sandbox
+        self.merchant_id = merchant_id
+        self.merchant_key = merchant_key
+        self._base_url = "https://api.shwary.com/api/v1/merchants"
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            timeout=timeout,
+            headers={
+                "x-merchant-id": merchant_id,
+                "x-merchant-key": merchant_key,
+                "Content-Type": "application/json",
+                "User-Agent": "Shwary-Python-SDK/0.1.0"
+            }
+        )
+
+    async def close(self):
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def initiate_payment(self, country: str, amount: float, phone_number: str, callback_url: str = None) -> dict:
+        """Initie une demande de paiement."""
+    
+        endpoint, json_data = prepare_payment_request(country, amount, phone_number, callback_url, self.is_sandbox)
+        
+        response = await self._client.post(endpoint, json=json_data)
+        
+        # Gestion centralisée des erreurs
+        raise_from_response(response)
+        
+        return response.json()
+    
+    async def get_transaction(self, transaction_id: str) -> dict:
+        """
+        Récupère les détails d'une transaction unique à partir de son ID.
+        """
+        endpoint: str = f"/transactions/{transaction_id}"
+        response = await self._client.get(endpoint)
+        
+        raise_from_response(response)
+        
+        return response.json()

shwary_python-1.0.1/shwary/clients/sync.py

@@ -0,0 +1,59 @@
+import httpx
+from ..core import prepare_payment_request
+from ..exceptions import raise_from_response
+
+
+class Shwary:
+    """
+    Client synchrone pour l'API Shwary.
+    À utiliser pour des scripts `standard, Django, Flask,` etc.
+    Doit être utilisé comme context manager ou fermé manuellement.
+    """
+    __slots__ = ('merchant_id', 'merchant_key', 'is_sandbox', '_client', '_base_url')
+
+    def __init__(self, merchant_id: str, merchant_key: str, is_sandbox: bool = False, timeout: float = 30.0):
+        self.is_sandbox = is_sandbox
+        self.merchant_id = merchant_id
+        self.merchant_key = merchant_key
+        self._base_url = "https://api.shwary.com/api/v1/merchants"
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            timeout=timeout,
+            headers={
+                "x-merchant-id": merchant_id,
+                "x-merchant-key": merchant_key,
+                "Content-Type": "application/json",
+                "User-Agent": "Shwary-Python-SDK/0.1.0"
+            }
+        )
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def initiate_payment(self, country: str, amount: float, phone_number: str, callback_url: str = None) -> dict:
+        """Initie une demande de paiement."""
+
+        endpoint, json_data = prepare_payment_request(country, amount, phone_number, callback_url, self.is_sandbox)
+        
+        response = self._client.post(endpoint, json=json_data)
+        
+        raise_from_response(response)
+        
+        return response.json()
+    
+    def get_transaction(self, transaction_id: str) -> dict:
+        """
+        Récupère les détails d'une transaction unique à partir de son ID.
+        """
+        endpoint: str = f"/transactions/{transaction_id}"
+        response = self._client.get(endpoint)
+        
+        raise_from_response(response)
+        
+        return response.json()

shwary_python-1.0.1/shwary/core.py

@@ -0,0 +1,32 @@
+from typing import Any
+from .schemas import PaymentPayload, CountryCode
+from .exceptions import ValidationError
+
+def prepare_payment_request(
+    country: CountryCode | str,
+    amount: float, 
+    phone: str, 
+    callback: str, 
+    is_sandbox: bool
+) -> tuple[str, dict[str, Any]]:
+    """
+    Prépare l'URL et le Payload validé.
+    Partagé par les clients Sync et Async pour éviter la duplication de logique métier.
+    """
+    # Validation & Conversion
+    try:
+        country_enum: CountryCode = CountryCode(country) if isinstance(country, str) else country
+        payload: PaymentPayload = PaymentPayload(
+            amount=amount,
+            clientPhoneNumber=phone,
+            callbackUrl=callback,
+            country_target=country_enum
+        )
+    except ValueError as e:
+        # On capture les erreurs Pydantic pour les relancer en ValidationError du SDK
+        raise ValidationError(str(e)) from e
+
+    env_path: str = "sandbox/" if is_sandbox else ""
+    endpoint: str = f"/payment/{env_path}{country_enum.value}"
+
+    return endpoint, payload.model_dump(exclude={'country_target'}, exclude_none=True)

shwary_python-1.0.1/shwary/exceptions.py

@@ -0,0 +1,41 @@
+class ShwaryError(Exception):
+    """Exception de base pour toutes les erreurs Shwary."""
+    pass
+
+class ValidationError(ShwaryError):
+    """Levée avant même l'envoi de la requête (ex: mauvais numéro)."""
+    pass
+
+class AuthenticationError(ShwaryError):
+    """Levée sur une erreur 401 (Clé API invalide)."""
+    pass
+
+class InsufficientFundsError(ShwaryError):
+    """Levée si le solde marchand est insuffisant ou règles métiers non respectées."""
+    pass
+
+class ShwaryAPIError(ShwaryError):
+    """Erreur générique retournée par l'API (400, 500, etc.)."""
+    def __init__(self, status_code: int, message: str, raw_response: dict = None):
+        self.status_code = status_code
+        self.raw_response = raw_response
+        super().__init__(f"Shwary Error {status_code}: {message}")
+
+def raise_from_response(response):
+    """Helper pour convertir une réponse HTTP en exception Python."""
+    if response.is_success:
+        return
+
+    status = response.status_code
+    try:
+        data = response.json()
+        message = data.get("message", response.text)
+    except Exception:
+        message = response.text
+
+    if status == 401:
+        raise AuthenticationError(f"Échec d'authentification : {message}")
+    elif status == 400 and "balance" in message.lower():
+        raise InsufficientFundsError(message)
+    else:
+        raise ShwaryAPIError(status, message, raw_response=data if 'data' in locals() else None)

shwary_python-1.0.1/shwary/schemas.py

@@ -0,0 +1,56 @@
+from enum import Enum
+from typing import Optional
+import phonenumbers
+from phonenumbers import NumberParseException
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+class CountryCode(str, Enum):
+    DRC = "DRC"
+    KENYA = "KE"
+    UGANDA = "UG"
+
+class PaymentPayload(BaseModel):
+    amount: float = Field(..., gt=0, description="Montant de la transaction")
+    clientPhoneNumber: str = Field(..., description="Numéro au format international")
+    callbackUrl: Optional[str] = None
+    country_target: CountryCode = Field(..., exclude=True)
+
+    @field_validator("clientPhoneNumber")
+    @classmethod
+    def validate_phone(cls, v: str) -> str:
+        try:
+            # LazyParsing pour accepter +243... ou 243...
+            parsed = phonenumbers.parse(v, None)
+            if not phonenumbers.is_valid_number(parsed):
+                raise ValueError("Numéro de téléphone invalide.")
+            
+            # Formatage strict E.164 (ex: +24381...) requis par Shwary
+            return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
+        except NumberParseException:
+            raise ValueError("Format de numéro impossible à analyser.")
+
+    @model_validator(mode='after')
+    def validate_country_consistency(self):
+        """
+        Fait une validation croisée :
+        On ne peut pas envoyer un numéro +254 (Kenya) vers l'endpoint DRC
+        """
+
+        phone: str = self.clientPhoneNumber
+        country: CountryCode = self.country_target
+        
+        prefixes: dict[CountryCode, str] = {
+            CountryCode.DRC: "+243",
+            CountryCode.KENYA: "+254",
+            CountryCode.UGANDA: "+256"
+        }
+        
+        expected_prefix = prefixes.get(country)
+        if expected_prefix and not phone.startswith(expected_prefix):
+             raise ValueError(f"Le numéro {phone} ne correspond pas au pays ciblé ({country.value}).")
+        
+        # Règle métier Shwary : Montant min pour RDC
+        if country == CountryCode.DRC and self.amount < 2900:
+             raise ValueError("Le montant minimum pour la RDC est de 2900 CDF.")
+             
+        return self

shwary_python-1.0.1/shwary/tests/test_client.py

@@ -0,0 +1,90 @@
+import pytest
+import respx
+from httpx import Response
+from shwary import Shwary
+from shwary.exceptions import ValidationError, AuthenticationError
+
+# --- FIXTURES (Données de test) ---
+@pytest.fixture
+def client() -> Shwary:
+    """Crée un client synchrone pour les tests."""
+    return Shwary(
+        merchant_id="merchant-test-id",
+        merchant_key="merchant-test-key",
+        is_sandbox=True
+    )
+
+
+def test_validation_fail_fast(client):
+    """Vérifie que le SDK bloque les requêtes invalides localement."""
+    # Test numéro invalide
+    with pytest.raises(ValidationError) as exc:
+        client.initiate_payment("DRC", 5000, "ceci n'est pas un numéro")
+    
+    # Vérification de la présence d'un mot clé réellement présent dans le message d'erreur
+    error_msg = str(exc.value)
+    assert "impossible à analyser" in error_msg or "invalide" in error_msg
+
+    # Test montant trop bas pour la RDC
+    with pytest.raises(ValidationError) as exc:
+        client.initiate_payment("DRC", 100, "+243840000000")
+    assert "2900" in str(exc.value)
+
+@respx.mock
+def test_initiate_payment_success(client):
+    """Simule une réponse 200 OK de l'API Shwary."""
+    
+    # On définit ce que l'API est censée répondre
+    mock_response: dict[str, bool | str] = {
+        "id": "trans-123",
+        "status": "pending",
+        "isSandbox": True
+    }
+    
+    # Interception de la requête POST vers l'URL sandbox
+    route = respx.post("https://api.shwary.com/api/v1/merchants/payment/sandbox/DRC").mock(
+        return_value=Response(200, json=mock_response)
+    )
+
+    # On initialise la demande de paiement
+    response = client.initiate_payment("DRC", 5000, "+243972345678")
+
+    # Vérifications
+    assert route.called
+    assert response["id"] == "trans-123"
+    assert response["status"] == "pending"
+
+@respx.mock
+def test_authentication_error(client):
+    """Simule une erreur 401 (Mauvaise clé API)."""
+    
+    respx.post("https://api.shwary.com/api/v1/merchants/payment/sandbox/KE").mock(
+        return_value=Response(401, json={"message": "Invalid merchant key"})
+    )
+
+    with pytest.raises(AuthenticationError) as exc:
+        client.initiate_payment("KE", 1000, "+254700000000")
+    
+    assert "Invalid merchant key" in str(exc.value)
+
+@respx.mock
+def test_get_transaction_success(client):
+    """Vérifie la récupération d'une transaction par ID."""
+    transaction_id = "c0fdfe50-24be-4de1-9f66-84608fd45a5f"
+    
+    mock_response: dict[str, int | str] = {
+        "id": transaction_id,
+        "status": "completed",
+        "amount": 5000
+    }
+    
+    # On intercepte le GET
+    route = respx.get(f"https://api.shwary.com/api/v1/merchants/transactions/{transaction_id}").mock(
+        return_value=Response(200, json=mock_response)
+    )
+
+    response = client.get_transaction(transaction_id)
+
+    assert route.called
+    assert response["id"] == transaction_id
+    assert response["status"] == "completed"

shwary_python-1.0.1/shwary/tests/test_client_async.py

@@ -0,0 +1,30 @@
+import pytest
+import respx
+from httpx import Response
+from shwary import ShwaryAsync
+
+@pytest.fixture
+def async_client() -> ShwaryAsync:
+    """Crée un client asynchrone pour les tests."""
+    return ShwaryAsync(
+        merchant_id="merchant-test-id",
+        merchant_key="merchant-test-key",
+        is_sandbox=True
+    )
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_async_payment_success(async_client):
+    """Vérifie que le client Async fonctionne aussi."""
+    
+    mock_response: dict[str, str] = {"id": "async-123", "status": "completed"}
+    
+    respx.post("https://api.shwary.com/api/v1/merchants/payment/sandbox/UG").mock(
+        return_value=Response(200, json=mock_response)
+    )
+
+    # Notez l'utilisation de 'async with' et 'await'
+    async with async_client as c:
+        response = await c.initiate_payment("UG", 5000, "+256700000000")
+
+    assert response["id"] == "async-123"