malipo 1.0.0__py3-none-any.whl

malipo/__init__.py

@@ -0,0 +1,4 @@
+from .client import Malipo
+from .errors import MalipoError
+
+__all__ = ["Malipo", "MalipoError"]

malipo/client.py

@@ -0,0 +1,111 @@
+import json
+import hmac
+import hashlib
+import requests
+from typing import Optional, Any, Dict
+from .types import (
+    MalipoEnvironment, 
+    MalipoTransaction, 
+    MalipoBalance, 
+    ChargeCreateParams,
+    MalipoEvent
+)
+from .errors import MalipoError
+
+class Malipo:
+    def __init__(self, api_key: str, environment: Optional[MalipoEnvironment] = None, base_url: Optional[str] = None):
+        if not api_key:
+            raise ValueError("Malipo API Key is required.")
+        
+        self.api_key = api_key
+        
+        # Infer environment from API Key if not explicitly provided
+        if environment:
+            self.environment = environment
+        else:
+            self.environment = "live" if api_key.startswith("sk_live_") else "sandbox"
+            
+        self.base_url = base_url or "https://lcwadpidhwptpzriqnjd.supabase.co/functions/v1"
+        
+        # Initialize resources
+        self.charges = ChargesResource(self)
+        self.transactions = TransactionsResource(self)
+        self.balance = BalanceResource(self)
+        self.webhooks = WebhooksResource()
+
+    def request(self, method: str, endpoint: str, params: Optional[Dict] = None, headers: Optional[Dict] = None):
+        url = f"{self.base_url}{endpoint}"
+        
+        default_headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "X-Client-Info": "malipo-python/1.0.0"
+        }
+        if headers:
+            default_headers.update(headers)
+            
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                json=params if method == "POST" else None,
+                params=params if method == "GET" else None,
+                headers=default_headers
+            )
+            
+            data = response.json()
+            
+            if not response.ok:
+                error_data = data.get("error", {})
+                raise MalipoError(
+                    message=error_data.get("message", "An unexpected error occurred"),
+                    status_code=response.status_code,
+                    code=error_data.get("code"),
+                    details=error_data
+                )
+                
+            return data
+            
+        except requests.exceptions.RequestException as e:
+            raise MalipoError(f"Network error: {str(e)}")
+
+class ChargesResource:
+    def __init__(self, client: Malipo):
+        self.client = client
+
+    def create(self, params: ChargeCreateParams, idempotency_key: Optional[str] = None) -> MalipoTransaction:
+        headers = {}
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        return self.client.request("POST", "/charge", params, headers)
+
+class TransactionsResource:
+    def __init__(self, client: Malipo):
+        self.client = client
+
+    def retrieve(self, transaction_id: str) -> MalipoTransaction:
+        return self.client.request("GET", "/transaction-status", {"id": transaction_id})
+
+class BalanceResource:
+    def __init__(self, client: Malipo):
+        self.client = client
+
+    def retrieve(self) -> MalipoBalance:
+        endpoint = "/live-balance" if self.client.environment == "live" else "/sandbox-balance"
+        return self.client.request("GET", endpoint)
+
+class WebhooksResource:
+    def construct_event(self, payload: str, signature: str, secret: str) -> MalipoEvent:
+        if not payload or not signature or not secret:
+            raise ValueError("Missing payload, signature, or secret for webhook verification.")
+            
+        expected_signature = hmac.new(
+            secret.encode("utf-8"),
+            payload.encode("utf-8"),
+            hashlib.sha256
+        ).hexdigest()
+        
+        if not hmac.compare_digest(expected_signature, signature):
+            raise MalipoError("Invalid webhook signature.")
+            
+        return json.loads(payload)

malipo/errors.py

@@ -0,0 +1,11 @@
+class MalipoError(Exception):
+    """Base error for all Malipo SDK errors"""
+    def __init__(self, message: str, status_code: int = None, code: str = None, details: dict = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.code = code
+        self.details = details
+
+    def __str__(self):
+        return f"{self.message} (status: {self.status_code}, code: {self.code})"

malipo/types.py

@@ -0,0 +1,51 @@
+from typing import TypedDict, List, Optional, Any, Literal
+
+MalipoNetwork = Literal["VODACOM_MPESA", "AIRTEL_MONEY", "ORANGE_MONEY"]
+MalipoTransactionStatus = Literal["pending", "succeeded", "failed", "expired"]
+MalipoEnvironment = Literal["sandbox", "live"]
+
+class MalipoConfig(TypedDict):
+    api_key: str
+    environment: Optional[MalipoEnvironment]
+    base_url: Optional[str]
+
+class ChargeCreateParams(TypedDict, total=False):
+    amount: float
+    currency: str
+    phone: str
+    network: MalipoNetwork
+    description: Optional[str]
+    metadata: Optional[dict]
+
+class MalipoTransaction(TypedDict):
+    id: str
+    object: Literal["transaction"]
+    amount: float
+    currency: str
+    status: MalipoTransactionStatus
+    phone: str
+    network: MalipoNetwork
+    environment: MalipoEnvironment
+    metadata: dict
+    created_at: str
+    updated_at: str
+    failure_reason: Optional[str]
+    failure_code: Optional[str]
+
+class MalipoBalanceAmount(TypedDict):
+    amount: float
+    currency: str
+
+class MalipoBalance(TypedDict):
+    object: Literal["balance"]
+    available: List[MalipoBalanceAmount]
+    pending: List[MalipoBalanceAmount]
+    updated_at: str
+
+class MalipoEvent(TypedDict):
+    id: str
+    object: Literal["event"]
+    type: str
+    environment: MalipoEnvironment
+    data: dict # contains object: MalipoTransaction
+    created_at: str

malipo-1.0.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: malipo
+Version: 1.0.0
+Summary: The official Python library for the Malipo Payment Gateway
+Author-email: Malipo Dev Team <dev@malipo.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.25.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Requires-Dist: responses>=0.18.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Malipo Python SDK
+
+The official Python library for the Malipo Payment Gateway. Securely accept Mobile Money payments (Vodacom MPesa, Orange Money, Airtel Money) in the DRC.
+
+## Installation
+
+```bash
+pip install malipo
+```
+
+## Quick Start
+
+```python
+from malipo import Malipo
+
+malipo = Malipo(api_key='sk_test_your_api_key')
+
+# Create a charge
+try:
+    charge = malipo.charges.create({
+        "amount": 10,
+        "currency": "USD",
+        "phone": "243810000000",
+        "network": "VODACOM_MPESA",
+        "description": "Order #123"
+    }, idempotency_key='unique_order_id_123')
+
+    print(f"Charge initiated: {charge['id']}")
+    print(f"Status: {charge['status']}") # 'pending'
+except Exception as e:
+    print(f"Charge failed: {e}")
+```
+
+## Features
+
+### 🔐 Idempotency
+Protect against duplicate charges by providing an `idempotency_key` in the options.
+
+### 🔄 Environment Detection
+The SDK automatically switches between `sandbox` and `live` environments based on your API key prefix (`sk_test_` vs `sk_live_`).
+
+### 📊 Balance Check
+Check your available and pending balances for your current environment.
+
+```python
+balance = malipo.balance.retrieve()
+print(f"Available USD: {balance['available'][0]['amount']}")
+```
+
+## Webhooks
+
+```python
+from flask import Flask, request
+from malipo import Malipo
+
+app = Flask(__name__)
+malipo = Malipo(api_key='...')
+
+@app.route('/webhooks/malipo', methods=['POST'])
+def handle_webhook():
+    signature = request.headers.get('X-Webhook-Signature')
+    payload = request.get_data(as_text=True)
+    
+    try:
+        event = malipo.webhooks.construct_event(
+            payload=payload,
+            signature=signature,
+            secret='whsec_your_secret'
+        )
+        
+        if event['type'] == 'charge.succeeded':
+            charge = event['data']['object']
+            print(f"Payment successful: {charge['id']}")
+            
+        return "OK", 200
+    except Exception as e:
+        return str(e), 400
+```
+
+## License
+MIT

malipo-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+malipo/__init__.py,sha256=M2cWLNI3H76rY5UzZRjJ7L3vrf27PIt5SQEusek9fPw,96
+malipo/client.py,sha256=cSJjkcW6jmFZqRzdD965xxMIbUakLabkVCyYi-BMgP4,3949
+malipo/errors.py,sha256=rd1yvMrw9BlMMlwRZ4BOexiAM9LH3R5CTswsS7RA5cQ,445
+malipo/types.py,sha256=JV-Gxz7nLuoCQvGkyu-cVTcDcblYbQcy1gFYNnSfYGE,1360
+malipo-1.0.0.dist-info/METADATA,sha256=nSpPN-3vqPry9wAYw2bUBRRsBMhGk2yZDd5MkVHj8Qk,2397
+malipo-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+malipo-1.0.0.dist-info/RECORD,,

malipo-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any