reevit 0.9.1__py3-none-any.whl

reevit/__init__.py

@@ -0,0 +1,11 @@
+from ._version import __version__
+from .client import Reevit, ReevitAPIError
+from .webhooks import sign_webhook_payload, verify_webhook_signature
+
+__all__ = [
+    "Reevit",
+    "ReevitAPIError",
+    "verify_webhook_signature",
+    "sign_webhook_payload",
+    "__version__",
+]

reevit/_version.py

@@ -0,0 +1,6 @@
+# Single source of truth for the SDK version.
+# Read by setup.py (via exec, without importing the package) and by
+# client.py for the X-Reevit-Client-Version header. Keep this file
+# free of imports so it stays loadable in build environments where
+# runtime dependencies are not installed.
+__version__ = "0.9.1"

reevit/client.py

@@ -0,0 +1,92 @@
+import requests
+import warnings
+from typing import Optional, Dict, Any
+from ._version import __version__
+from .services.payments import PaymentsService
+from .services.connections import ConnectionsService
+from .services.subscriptions import SubscriptionsService
+from .services.fraud import FraudService
+from .services.customers import CustomersService
+from .services.payment_links import PaymentLinksService
+from .services.checkout_sessions import CheckoutSessionsService
+from .services.webhooks import WebhooksService
+from .services.routing_rules import RoutingRulesService
+from .services.invoices import InvoicesService
+
+API_BASE_URL_PRODUCTION = 'https://api.reevit.io'
+DEFAULT_TIMEOUT = 30
+
+class ReevitAPIError(Exception):
+    def __init__(self, status_code: int, message: str, code: Optional[str] = None, details: Optional[Dict[str, Any]] = None):
+        self.status_code = status_code
+        self.code = code or "api_error"
+        self.details = details or {}
+        super().__init__(message)
+
+def is_sandbox_key(api_key: str) -> bool:
+    return api_key.startswith('pfk_test_')
+
+class Reevit:
+    def __init__(self, api_key: str, org_id: Optional[str] = None, base_url: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT):
+        if base_url is None:
+            base_url = API_BASE_URL_PRODUCTION
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Content-Type": "application/json",
+            "User-Agent": "@reevit/python",
+            "X-Reevit-Key": api_key,
+            "X-Reevit-Client": "@reevit/python",
+            "X-Reevit-Client-Version": __version__,
+        })
+        if org_id:
+            self.session.headers["X-Org-Id"] = org_id
+        self.base_url = base_url.rstrip("/")
+        self.org_id = org_id
+        self.timeout = timeout
+
+        self.payments = PaymentsService(self)
+        self.connections = ConnectionsService(self)
+        self.subscriptions = SubscriptionsService(self)
+        self.fraud = FraudService(self)
+        self.customers = CustomersService(self)
+        self.payment_links = PaymentLinksService(self)
+        self.checkout_sessions = CheckoutSessionsService(self)
+        self.webhooks = WebhooksService(self)
+        self.routing_rules = RoutingRulesService(self)
+        self.invoices = InvoicesService(self)
+
+    def request(self, method: str, path: str, **kwargs) -> Any:
+        if not path.startswith("/v1/pay/") and not self.org_id:
+            warnings.warn(
+                "org_id should be provided for authenticated Reevit API requests; org-less usage is deprecated.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        url = f"{self.base_url}{path}"
+        if 'timeout' not in kwargs:
+            kwargs['timeout'] = self.timeout
+        headers = kwargs.pop('headers', None)
+        if headers:
+            merged_headers = dict(self.session.headers)
+            merged_headers.update(headers)
+            kwargs['headers'] = merged_headers
+        response = self.session.request(method, url, **kwargs)
+        if response.status_code == 204:
+            return None
+
+        if not response.ok:
+            try:
+                payload = response.json()
+            except ValueError:
+                payload = {}
+            raise ReevitAPIError(
+                response.status_code,
+                payload.get("message") or response.text or "request failed",
+                payload.get("code"),
+                payload.get("details"),
+            )
+
+        try:
+            return response.json()
+        except ValueError:
+            return None

reevit/services/__init__.py

@@ -0,0 +1,2 @@
+# Regular package marker: without this, setuptools' find_packages() treats
+# reevit.services as a namespace package and omits it from built distributions.

reevit/services/checkout_sessions.py

@@ -0,0 +1,10 @@
+from typing import Dict, Any, Optional
+
+
+class CheckoutSessionsService:
+    def __init__(self, client):
+        self.client = client
+
+    def create(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/checkout/sessions", json=data, headers=headers)

reevit/services/connections.py

@@ -0,0 +1,55 @@
+from typing import List, Dict, Any, Optional
+
+class ConnectionsService:
+    def __init__(self, client):
+        self.client = client
+
+    def create(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/connections", json=data, headers=headers)
+
+    def list(self, **params: Any) -> List[Dict[str, Any]]:
+        response = self.client.request("GET", "/v1/connections", params=params)
+        if isinstance(response, dict):
+            return response.get("connections", [])
+        return response
+
+    def get(self, connection_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/connections/{connection_id}")
+
+    def delete(self, connection_id: str, idempotency_key: Optional[str] = None) -> None:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        self.client.request("DELETE", f"/v1/connections/{connection_id}", headers=headers)
+
+    def validate(self, connection_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/connections/{connection_id}/validate", headers=headers)
+
+    def list_audit(self, connection_id: str, **params: Any) -> List[Dict[str, Any]]:
+        response = self.client.request("GET", f"/v1/connections/{connection_id}/audit", params=params)
+        if isinstance(response, dict):
+            return response.get("audit", [])
+        return response
+
+    def update_labels(self, connection_id: str, labels: List[str], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request(
+            "PATCH",
+            f"/v1/connections/{connection_id}/labels",
+            json={"labels": labels},
+            headers=headers,
+        )
+
+    def update_status(self, connection_id: str, status: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request(
+            "PATCH",
+            f"/v1/connections/{connection_id}/status",
+            json={"status": status},
+            headers=headers,
+        )
+
+    def test(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> bool:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        resp = self.client.request("POST", "/v1/connections/test", json=data, headers=headers)
+        return resp.get("success", False)

reevit/services/customers.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, List, Optional
+
+
+def _extract_list(payload: Any, key: str) -> List[Dict[str, Any]]:
+    if isinstance(payload, dict):
+        return payload.get(key, [])
+    return payload or []
+
+
+class CustomersService:
+    def __init__(self, client):
+        self.client = client
+
+    def list(self, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/customers", params=params), "customers")
+
+    def create(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/customers", json=data, headers=headers)
+
+    def get(self, customer_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/customers/{customer_id}")
+
+    def update(self, customer_id: str, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("PATCH", f"/v1/customers/{customer_id}", json=data, headers=headers)
+
+    def delete(self, customer_id: str, idempotency_key: Optional[str] = None) -> None:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        self.client.request("DELETE", f"/v1/customers/{customer_id}", headers=headers)
+
+    def lookup(self, external_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", "/v1/customers/lookup", params={"external_id": external_id})
+
+    def top(self, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/customers/top", params=params), "customers")
+
+    def payment_history(self, customer_id: str, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", f"/v1/customers/{customer_id}/payments", params=params), "payments")

reevit/services/fraud.py

@@ -0,0 +1,11 @@
+from typing import Dict, Any
+
+class FraudService:
+    def __init__(self, client):
+        self.client = client
+
+    def get(self) -> Dict[str, Any]:
+        return self.client.request("GET", "/v1/policies/fraud")
+
+    def update(self, policy: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client.request("POST", "/v1/policies/fraud", json=policy)

reevit/services/invoices.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List, Optional
+
+
+def _extract_list(payload: Any, key: str) -> List[Dict[str, Any]]:
+    if isinstance(payload, dict):
+        return payload.get(key, [])
+    return payload or []
+
+
+class InvoicesService:
+    def __init__(self, client):
+        self.client = client
+
+    def list(self, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/invoices", params=params), "invoices")
+
+    def get(self, invoice_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/invoices/{invoice_id}")
+
+    def update(self, invoice_id: str, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("PATCH", f"/v1/invoices/{invoice_id}", json=data, headers=headers)
+
+    def cancel(self, invoice_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/invoices/{invoice_id}/cancel", json={}, headers=headers)
+
+    def retry(self, invoice_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/invoices/{invoice_id}/retry", json={}, headers=headers)

reevit/services/payment_links.py

@@ -0,0 +1,42 @@
+from typing import Any, Dict, List, Optional
+
+
+def _extract_list(payload: Any, key: str) -> List[Dict[str, Any]]:
+    if isinstance(payload, dict):
+        return payload.get(key, [])
+    return payload or []
+
+
+class PaymentLinksService:
+    def __init__(self, client):
+        self.client = client
+
+    def list(self, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/payment-links", params=params), "payment_links")
+
+    def create(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/payment-links", json=data, headers=headers)
+
+    def get(self, payment_link_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/payment-links/{payment_link_id}")
+
+    def update(self, payment_link_id: str, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("PATCH", f"/v1/payment-links/{payment_link_id}", json=data, headers=headers)
+
+    def delete(self, payment_link_id: str, idempotency_key: Optional[str] = None) -> None:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        self.client.request("DELETE", f"/v1/payment-links/{payment_link_id}", headers=headers)
+
+    def get_stats(self, payment_link_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/payment-links/{payment_link_id}/stats")
+
+    def list_payments(self, payment_link_id: str, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(
+            self.client.request("GET", f"/v1/payment-links/{payment_link_id}/payments", params=params),
+            "payments",
+        )
+
+    def get_by_code(self, code: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/pay/{code}")

reevit/services/payments.py

@@ -0,0 +1,54 @@
+from typing import List, Dict, Any, Optional
+
+class PaymentsService:
+    def __init__(self, client):
+        self.client = client
+
+    def create_intent(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/payments/intents", json=data, headers=headers)
+
+    def list(self, limit: int = 50, offset: int = 0) -> List[Dict[str, Any]]:
+        params = {"limit": limit, "offset": offset}
+        return self.client.request("GET", "/v1/payments", params=params)
+
+    def get(self, payment_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/payments/{payment_id}")
+
+    def update_intent(self, payment_id: str, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("PATCH", f"/v1/payments/intents/{payment_id}", json=data, headers=headers)
+
+    def confirm(self, payment_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/payments/{payment_id}/confirm", json={}, headers=headers)
+
+    def confirm_intent(self, payment_id: str, client_secret: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request(
+            "POST",
+            f"/v1/payments/{payment_id}/confirm-intent",
+            params={"client_secret": client_secret},
+            json={},
+            headers=headers,
+        )
+
+    def cancel(self, payment_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/payments/{payment_id}/cancel", json={}, headers=headers)
+
+    def retry(self, payment_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/payments/{payment_id}/retry", json={}, headers=headers)
+
+    def refund(self, payment_id: str, amount: Optional[int] = None, reason: Optional[str] = None, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        data = {}
+        if amount is not None:
+            data["amount"] = amount
+        if reason is not None:
+            data["reason"] = reason
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/payments/{payment_id}/refund", json=data, headers=headers)
+
+    def stats(self, **params: Any) -> Dict[str, Any]:
+        return self.client.request("GET", "/v1/payments/stats", params=params)

reevit/services/routing_rules.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List, Optional
+
+
+def _extract_list(payload: Any, key: str) -> List[Dict[str, Any]]:
+    if isinstance(payload, dict):
+        return payload.get(key, [])
+    return payload or []
+
+
+class RoutingRulesService:
+    def __init__(self, client):
+        self.client = client
+
+    def list(self) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/routing-rules"), "rules")
+
+    def create(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/routing-rules", json=data, headers=headers)
+
+    def get(self, rule_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/routing-rules/{rule_id}")
+
+    def update(self, rule_id: str, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("PATCH", f"/v1/routing-rules/{rule_id}", json=data, headers=headers)
+
+    def delete(self, rule_id: str, idempotency_key: Optional[str] = None) -> None:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        self.client.request("DELETE", f"/v1/routing-rules/{rule_id}", headers=headers)

reevit/services/subscriptions.py

@@ -0,0 +1,27 @@
+from typing import List, Dict, Any, Optional
+
+class SubscriptionsService:
+    def __init__(self, client):
+        self.client = client
+
+    def create(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/subscriptions", json=data, headers=headers)
+
+    def list(self, **params: Any) -> List[Dict[str, Any]]:
+        return self.client.request("GET", "/v1/subscriptions", params=params)
+
+    def get(self, subscription_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/subscriptions/{subscription_id}")
+
+    def update(self, subscription_id: str, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("PATCH", f"/v1/subscriptions/{subscription_id}", json=data, headers=headers)
+
+    def cancel(self, subscription_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/subscriptions/{subscription_id}/cancel", json={}, headers=headers)
+
+    def resume(self, subscription_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/subscriptions/{subscription_id}/resume", json={}, headers=headers)

reevit/services/webhooks.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List, Optional
+
+
+def _extract_list(payload: Any, key: str) -> List[Dict[str, Any]]:
+    if isinstance(payload, dict):
+        return payload.get(key, [])
+    return payload or []
+
+
+class WebhooksService:
+    def __init__(self, client):
+        self.client = client
+
+    def get_config(self) -> Dict[str, Any]:
+        return self.client.request("GET", "/v1/webhooks/config")
+
+    def upsert_config(self, data: Dict[str, Any], idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/webhooks/config", json=data, headers=headers)
+
+    def delete_config(self, idempotency_key: Optional[str] = None) -> None:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        self.client.request("DELETE", "/v1/webhooks/config", headers=headers)
+
+    def send_test(self, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", "/v1/webhooks/test", json={}, headers=headers)
+
+    def list_events(self, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/webhooks/events", params=params), "events")
+
+    def get_event(self, event_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/webhooks/events/{event_id}")
+
+    def replay_event(self, event_id: str, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self.client.request("POST", f"/v1/webhooks/events/{event_id}/replay", json={}, headers=headers)
+
+    def list_outbound(self, **params: Any) -> List[Dict[str, Any]]:
+        return _extract_list(self.client.request("GET", "/v1/webhooks/outbound", params=params), "outbound")
+
+    def get_outbound(self, outbound_id: str) -> Dict[str, Any]:
+        return self.client.request("GET", f"/v1/webhooks/outbound/{outbound_id}")

reevit/webhooks.py

@@ -0,0 +1,53 @@
+"""Webhook signature verification for Reevit outbound webhooks.
+
+Reevit signs every outbound webhook with HMAC-SHA256 over the **raw request
+body** and sends the result in the ``X-Reevit-Signature`` header as
+``sha256=<hex>``. The signed body includes a ``signature_timestamp`` field, so
+the signature also covers the timestamp (tamper protection). To additionally
+guard against replay of a captured-but-recent delivery, check that
+``signature_timestamp`` is recent after the signature verifies.
+
+IMPORTANT: verify against the exact bytes you received. Do not ``json.loads``
+and re-serialize the body first -- key order and whitespace must match what
+Reevit signed, or the signature will not match.
+"""
+
+import hashlib
+import hmac
+from typing import Optional, Union
+
+_SIGNATURE_PREFIX = "sha256="
+
+
+def _to_bytes(payload: Union[str, bytes]) -> bytes:
+    return payload.encode("utf-8") if isinstance(payload, str) else payload
+
+
+def sign_webhook_payload(payload: Union[str, bytes], secret: str) -> str:
+    """Compute the ``X-Reevit-Signature`` header value for a raw webhook body.
+
+    Returns ``sha256=<hex HMAC-SHA256 of the body>``. Primarily useful for tests.
+    """
+    digest = hmac.new(secret.encode("utf-8"), _to_bytes(payload), hashlib.sha256).hexdigest()
+    return _SIGNATURE_PREFIX + digest
+
+
+def verify_webhook_signature(
+    payload: Union[str, bytes],
+    signature: Optional[str],
+    secret: str,
+) -> bool:
+    """Verify a Reevit webhook signature in constant time.
+
+    :param payload: Raw request body, exactly as received (str or bytes).
+    :param signature: The ``X-Reevit-Signature`` header value (``sha256=...``).
+    :param secret: The signing secret for the webhook endpoint.
+    :returns: ``True`` only if the signature is present and valid.
+    """
+    if not signature or not secret:
+        return False
+
+    expected = sign_webhook_payload(payload, secret)
+
+    # compare_digest is constant-time and length-safe.
+    return hmac.compare_digest(expected, signature)

reevit-0.9.1.dist-info/METADATA

@@ -0,0 +1,452 @@
+Metadata-Version: 2.4
+Name: reevit
+Version: 0.9.1
+Summary: Reevit Python SDK
+Home-page: https://github.com/Reevit-Platform/python-sdk
+Author: Reevit
+License: MIT
+Project-URL: Documentation, https://docs.reevit.io
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Reevit Python SDK
+
+The official Python SDK for [Reevit](https://reevit.io) — a unified payment orchestration platform for Africa.
+
+[![PyPI version](https://img.shields.io/pypi/v/reevit.svg)](https://pypi.org/project/reevit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/reevit.svg)](https://pypi.org/project/reevit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install reevit==0.9.1
+```
+
+## Quick Start
+
+```python
+from reevit import Reevit
+
+client = Reevit(api_key="pfk_live_xxx", org_id="org_123")
+
+# Create a payment
+try:
+    payment = client.payments.create_intent({
+        "amount": 5000,  # 50.00 GHS
+        "currency": "GHS",
+        "method": "momo",
+        "country": "GH",
+        "customer_id": "cust_123",
+        "metadata": {
+            "order_id": "12345"
+        }
+    }, idempotency_key="order_12345")
+    print(f"Payment created: {payment['id']}")
+except Exception as e:
+    print(f"Error: {e}")
+
+# List payments
+payments = client.payments.list()
+print(payments)
+```
+
+## Server-created checkout sessions
+
+Create checkout sessions on your server, then pass `session["session_secret"]` to a browser SDK — [`@reevit/react`](https://www.npmjs.com/package/@reevit/react), [`@reevit/vue`](https://www.npmjs.com/package/@reevit/vue), or [`@reevit/svelte`](https://www.npmjs.com/package/@reevit/svelte) — to render the checkout UI.
+
+```python
+session = client.checkout_sessions.create(
+    {
+        "amount": 5000,
+        "currency": "GHS",
+        "method": "mobile_money",
+        "country": "GH",
+    },
+    idempotency_key="order_12345",
+)
+```
+
+## Idempotency
+
+Pass `idempotency_key` to safely retry intent creation without duplicates.
+
+```python
+payment = client.payments.create_intent(
+    {
+        "amount": 5000,
+        "currency": "GHS",
+        "method": "momo",
+        "country": "GH",
+    },
+    idempotency_key="order_12345",
+)
+```
+
+## Features
+
+- **Payments**: Create intents, update intents, confirm, confirm intent, cancel, retry, refund, stats
+- **Connections**: Manage PSP integrations, validation, labels, status, audit
+- **Subscriptions**: Manage recurring billing lifecycle
+- **Fraud**: Configure fraud rules
+- **Customers / Payment Links / Checkout Sessions / Webhooks / Routing Rules / Invoices**: Additional backend services
+
+`org_id` is supported directly on the client. Omitting it for authenticated requests still works for backward compatibility, but that mode is deprecated.
+
+---
+
+## Webhook Verification
+
+Reevit sends webhooks to notify your application of payment events. Always verify webhook signatures.
+
+### Understanding Webhooks
+
+There are **two types of webhooks** in Reevit:
+
+1. **Inbound Webhooks (PSP → Reevit)**: Webhooks from payment providers (Paystack, Flutterwave, etc.) to Reevit. Configure these in the PSP dashboard. Reevit handles them automatically.
+
+2. **Outbound Webhooks (Reevit → Your App)**: Webhooks from Reevit to your application. Configure in Reevit Dashboard and create a handler in your app.
+
+### Signature Format
+
+- **Header**: `X-Reevit-Signature: sha256=<hex-signature>`
+- **Signature**: `HMAC-SHA256(request_body, signing_secret)`
+
+### Getting Your Signing Secret
+
+1. Go to **Reevit Dashboard > Developers > Webhooks**
+2. Configure your webhook endpoint URL
+3. Copy the signing secret (starts with `whsec_`)
+4. Set environment variable: `REEVIT_WEBHOOK_SECRET=whsec_xxx...`
+
+### Flask Webhook Handler
+
+The SDK ships a constant-time verifier — `verify_webhook_signature(payload, signature, secret)` — so you do not have to reimplement HMAC. Pass the **raw** request body (not parsed-and-reserialized JSON), the `X-Reevit-Signature` header, and your signing secret.
+
+```python
+import os
+import logging
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+from flask import Flask, request, jsonify
+from reevit import verify_webhook_signature
+
+app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class PaymentData:
+    id: str
+    status: str
+    amount: int
+    currency: str
+    provider: str
+    customer_id: Optional[str] = None
+    metadata: Optional[Dict[str, str]] = None
+
+@dataclass
+class SubscriptionData:
+    id: str
+    customer_id: str
+    plan_id: str
+    status: str
+    amount: int
+    currency: str
+    interval: str
+    next_renewal_at: Optional[str] = None
+
+@app.route('/webhooks/reevit', methods=['POST'])
+def webhook():
+    payload = request.get_data()  # raw bytes — do not re-serialize
+    signature = request.headers.get('X-Reevit-Signature', '')
+    secret = os.environ.get('REEVIT_WEBHOOK_SECRET', '')
+
+    # Verify signature (required in production)
+    if not verify_webhook_signature(payload, signature, secret):
+        logger.warning('[Webhook] Invalid signature')
+        return jsonify({'error': 'Invalid signature'}), 401
+    
+    event = request.get_json()
+    event_type = event.get('type')
+    event_id = event.get('id')
+    
+    logger.info(f'[Webhook] Received: {event_type} ({event_id})')
+    
+    # Handle different event types
+    if event_type == 'reevit.webhook.test':
+        logger.info(f'[Webhook] Test received: {event.get("message")}')
+    
+    # Payment events
+    elif event_type == 'payment.succeeded':
+        data = PaymentData(**event.get('data', {}))
+        handle_payment_succeeded(data)
+    
+    elif event_type == 'payment.failed':
+        data = PaymentData(**event.get('data', {}))
+        handle_payment_failed(data)
+    
+    elif event_type == 'payment.refunded':
+        data = PaymentData(**event.get('data', {}))
+        handle_payment_refunded(data)
+    
+    elif event_type == 'payment.pending':
+        data = PaymentData(**event.get('data', {}))
+        logger.info(f'[Webhook] Payment pending: {data.id}')
+    
+    # Subscription events
+    elif event_type == 'subscription.created':
+        data = SubscriptionData(**event.get('data', {}))
+        handle_subscription_created(data)
+    
+    elif event_type == 'subscription.renewed':
+        data = SubscriptionData(**event.get('data', {}))
+        handle_subscription_renewed(data)
+    
+    elif event_type == 'subscription.canceled':
+        data = SubscriptionData(**event.get('data', {}))
+        handle_subscription_canceled(data)
+    
+    else:
+        logger.info(f'[Webhook] Unhandled event: {event_type}')
+    
+    return jsonify({'received': True})
+
+# Payment handlers
+def handle_payment_succeeded(data: PaymentData):
+    order_id = data.metadata.get('order_id') if data.metadata else None
+    logger.info(f'[Webhook] Payment succeeded: {data.id} for order {order_id}')
+    
+    # TODO: Implement your business logic
+    # - Update order status to "paid"
+    # - Send confirmation email to customer
+    # - Trigger fulfillment process
+
+def handle_payment_failed(data: PaymentData):
+    logger.info(f'[Webhook] Payment failed: {data.id}')
+    
+    # TODO: Implement your business logic
+    # - Update order status to "payment_failed"
+    # - Send notification to customer
+    # - Allow retry
+
+def handle_payment_refunded(data: PaymentData):
+    order_id = data.metadata.get('order_id') if data.metadata else None
+    logger.info(f'[Webhook] Payment refunded: {data.id} for order {order_id}')
+    
+    # TODO: Implement your business logic
+    # - Update order status to "refunded"
+    # - Restore inventory if applicable
+
+# Subscription handlers
+def handle_subscription_created(data: SubscriptionData):
+    logger.info(f'[Webhook] Subscription created: {data.id} for customer {data.customer_id}')
+    
+    # TODO: Implement your business logic
+    # - Grant access to subscription features
+    # - Send welcome email
+
+def handle_subscription_renewed(data: SubscriptionData):
+    logger.info(f'[Webhook] Subscription renewed: {data.id}')
+    
+    # TODO: Implement your business logic
+    # - Extend access period
+    # - Send renewal confirmation
+
+def handle_subscription_canceled(data: SubscriptionData):
+    logger.info(f'[Webhook] Subscription canceled: {data.id}')
+    
+    # TODO: Implement your business logic
+    # - Revoke access at end of billing period
+    # - Send cancellation confirmation
+
+if __name__ == '__main__':
+    app.run(port=8080)
+```
+
+### Django Webhook Handler
+
+```python
+# views.py
+import json
+import os
+import logging
+from django.http import JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_POST
+from reevit import verify_webhook_signature
+
+logger = logging.getLogger(__name__)
+
+@csrf_exempt
+@require_POST
+def reevit_webhook(request):
+    payload = request.body  # raw bytes — do not re-serialize
+    signature = request.headers.get('X-Reevit-Signature', '')
+    secret = os.environ.get('REEVIT_WEBHOOK_SECRET', '')
+    
+    if not verify_webhook_signature(payload, signature, secret):
+        return JsonResponse({'error': 'Invalid signature'}, status=401)
+    
+    event = json.loads(payload)
+    event_type = event.get('type')
+    
+    logger.info(f'[Webhook] Received: {event_type}')
+    
+    if event_type == 'payment.succeeded':
+        data = event.get('data', {})
+        order_id = data.get('metadata', {}).get('order_id')
+        # Fulfill order, send confirmation email
+        logger.info(f'Payment succeeded for order {order_id}')
+    
+    elif event_type == 'payment.failed':
+        # Notify customer, allow retry
+        pass
+    
+    elif event_type == 'subscription.renewed':
+        # Extend access
+        pass
+    
+    elif event_type == 'subscription.canceled':
+        # Revoke access
+        pass
+    
+    return JsonResponse({'received': True})
+```
+
+### FastAPI Webhook Handler
+
+```python
+from fastapi import FastAPI, Request, HTTPException
+from pydantic import BaseModel
+from typing import Optional, Dict
+import os
+import logging
+from reevit import verify_webhook_signature
+
+app = FastAPI()
+logger = logging.getLogger(__name__)
+
+class PaymentData(BaseModel):
+    id: str
+    status: str
+    amount: int
+    currency: str
+    provider: str
+    customer_id: Optional[str] = None
+    metadata: Optional[Dict[str, str]] = None
+
+class SubscriptionData(BaseModel):
+    id: str
+    customer_id: str
+    plan_id: str
+    status: str
+    amount: int
+    currency: str
+    interval: str
+    next_renewal_at: Optional[str] = None
+
+@app.post('/webhooks/reevit')
+async def webhook(request: Request):
+    payload = await request.body()  # raw bytes — do not re-serialize
+    signature = request.headers.get('X-Reevit-Signature', '')
+    secret = os.environ.get('REEVIT_WEBHOOK_SECRET', '')
+    
+    if not verify_webhook_signature(payload, signature, secret):
+        raise HTTPException(status_code=401, detail='Invalid signature')
+    
+    event = await request.json()
+    event_type = event.get('type')
+    
+    logger.info(f'[Webhook] Received: {event_type}')
+    
+    # Payment events
+    if event_type == 'payment.succeeded':
+        data = PaymentData(**event.get('data', {}))
+        order_id = data.metadata.get('order_id') if data.metadata else None
+        logger.info(f'Payment succeeded: {data.id} for order {order_id}')
+        # Fulfill order, send confirmation email
+    
+    elif event_type == 'payment.failed':
+        # Notify customer, allow retry
+        pass
+    
+    # Subscription events
+    elif event_type == 'subscription.renewed':
+        data = SubscriptionData(**event.get('data', {}))
+        logger.info(f'Subscription renewed: {data.id}')
+        # Extend access
+    
+    elif event_type == 'subscription.canceled':
+        data = SubscriptionData(**event.get('data', {}))
+        logger.info(f'Subscription canceled: {data.id}')
+        # Revoke access
+    
+    return {'received': True}
+```
+
+## Supported PSPs
+
+| Provider | Countries | Payment Methods |
+|----------|-----------|-----------------|
+| Paystack | NG, GH, ZA, KE | Card, Mobile Money, Bank Transfer |
+| Flutterwave | NG, GH, KE, ZA + | Card, Mobile Money, Bank Transfer |
+| Hubtel | GH | Mobile Money |
+| Stripe | Global (50+) | Card, Apple Pay, Google Pay |
+| Monnify | NG | Card, Bank Transfer, USSD |
+| M-Pesa | KE, TZ | Mobile Money (STK Push) |
+
+---
+
+## Release Notes
+
+### v0.9.1
+
+- Added `verify_webhook_signature` / `sign_webhook_payload` helpers (constant-time HMAC-SHA256 verification of the `X-Reevit-Signature` header)
+- Version is now sourced from `reevit._version` and sent as the `X-Reevit-Client-Version` header
+
+### v0.9.0
+
+- Added server-created checkout sessions
+- Version alignment across all Reevit SDKs
+- Updated documentation and webhook examples
+- Added support for Apple Pay and Google Pay
+- Updated supported PSPs and payment methods documentation
+
+---
+
+## Environment Variables
+
+```bash
+export REEVIT_API_KEY=pfk_live_xxx
+export REEVIT_ORG_ID=org_xxx
+export REEVIT_WEBHOOK_SECRET=whsec_xxx  # Get from Dashboard > Developers > Webhooks
+```
+
+---
+
+## Support
+
+- **Documentation**: [https://docs.reevit.io](https://docs.reevit.io)
+- **GitHub Issues**: [https://github.com/Reevit-Platform/backend/issues](https://github.com/Reevit-Platform/backend/issues)
+- **Email**: support@reevit.io
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

reevit-0.9.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+reevit/__init__.py,sha256=prpmjhIWFfsweJo7XyFwjkOzfCw4o9zEWPKp2nu7Jwc,276
+reevit/_version.py,sha256=VfQ_lu-jIwCa8kx_s31JSCAL4SGFr08ExXCvvbz7Ejs,312
+reevit/client.py,sha256=Ygzd4KBI6pRSVfvQo7__p88JV2_Hk6O1U386UTR_HwY,3617
+reevit/webhooks.py,sha256=q8uID1jmpqYGOiYQEt16dxCvbnpYrx4-MT-kHvbbQks,1999
+reevit/services/__init__.py,sha256=p1afTZx1O_Sxog_xOa9yOi8s9zcXyBW5jyYoFujbhwc,155
+reevit/services/checkout_sessions.py,sha256=X52wXJcyBHO7dRtdePhQF3sm4IOZBzChsGpYmtuKRrs,415
+reevit/services/connections.py,sha256=x3ohIlL5hsi3Dy-MFm2wiHm_0y3UinnPSQcEPNHwL1A,2753
+reevit/services/customers.py,sha256=1DRHki6gyLPhDK7MKl37c6mqsvM82x063h1n7uD3Tno,1970
+reevit/services/fraud.py,sha256=WqoMt-d2pEviZkME27ROGbmRsSWqdrzCWTva7xCPZco,356
+reevit/services/invoices.py,sha256=elJWEkGO59hqRJXNfRmQCO3ydazuRFZQz1V4RUXqHxg,1459
+reevit/services/payment_links.py,sha256=o04oe2-OvKABN8KyNbJZ7FvQSLyQVDInboFPbH1oeVA,2011
+reevit/services/payments.py,sha256=A1TjWdW00USwcWgfhoXlW5JbEpW2t-hcT_XQt15seIU,3000
+reevit/services/routing_rules.py,sha256=vkKyyqatDuVnEDSgPLjFDXI8OiNH7gei2Iyc267ebto,1394
+reevit/services/subscriptions.py,sha256=66gtMwBuGSPUWA_Hybg82kMx2mSUR5bIaJwju_AgKpM,1617
+reevit/services/webhooks.py,sha256=Bgx2Z-Ll9fvq9AB24rODbqsa3nGHY2zl9qOFJeWECug,2117
+reevit-0.9.1.dist-info/licenses/LICENSE,sha256=UDLWW01GC5P5RdsVrq3mq2xaIol__OoHOXNb_iSTh9M,1063
+reevit-0.9.1.dist-info/METADATA,sha256=ar707ijBl-qxnXc_KiqR0ma_5_O-jcqKtCv2_AwkWiw,13904
+reevit-0.9.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+reevit-0.9.1.dist-info/top_level.txt,sha256=5fiQTE6CazGDmrY12b129nI2f-W7GVrCMMOuU6AVb3U,7
+reevit-0.9.1.dist-info/RECORD,,

reevit-0.9.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

reevit-0.9.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Reevit
+
+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.

reevit-0.9.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+reevit