paybridge-np 0.1.0__tar.gz

paybridge_np-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+.mypy_cache/
+.pytest_cache/

paybridge_np-0.1.0/LICENSE

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

paybridge_np-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.1
+Name: paybridge-np
+Version: 0.1.0
+Summary: Official Python SDK for the PayBridgeNP payment gateway - accept eSewa, Khalti, and ConnectIPS through a single API
+Project-URL: Homepage, https://paybridgenp.com
+Project-URL: Documentation, https://docs.paybridgenp.com
+Project-URL: Repository, https://github.com/paybridgenp/paybridgenp-python-sdk
+Project-URL: Issues, https://github.com/paybridgenp/paybridgenp-python-sdk/issues
+Author-email: PayBridgeNP <support@paybridgenp.com>
+License: MIT
+License-File: LICENSE
+Keywords: connectips,esewa,khalti,nepal,nepal-payments,paybridge,payment-gateway,payments
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Description-Content-Type: text/markdown
+
+# paybridge-np
+
+Official Python SDK for the [PayBridgeNP](https://paybridgenp.com) payment gateway. Accept eSewa, Khalti, and ConnectIPS through a single API.
+
+## Installation
+
+```bash
+pip install paybridge-np
+```
+
+## Quick start
+
+```python
+from paybridge_np import PayBridge
+
+client = PayBridge(api_key="sk_live_...")  # from dashboard.paybridgenp.com
+
+# Create a checkout session
+session = client.checkout.create({
+    "amount": 250000,        # NPR 2,500 in paisa
+    "currency": "NPR",
+    "returnUrl": "https://mystore.com/success",
+    "cancelUrl": "https://mystore.com/cart",
+    "metadata": {"orderId": "ORD-7842"},
+    "customer": {
+        "name": "Ram Shrestha",
+        "email": "ram@example.com",
+        "phone": "9841000000",
+    },
+})
+
+# Redirect customer to hosted checkout
+# session["checkout_url"] => https://paybridgenp.com/checkout/cs_xxx
+```
+
+## Payments
+
+```python
+# List payments
+result = client.payments.list(limit=20)
+payments = result["data"]
+
+# Get a single payment
+payment = client.payments.retrieve("pay_xxx")
+```
+
+## Refunds
+
+```python
+refund = client.refunds.create({
+    "paymentId": "pay_xxx",
+    "amount": 100000,  # NPR 1,000 in paisa
+    "reason": "customer_request",
+})
+```
+
+## Webhooks
+
+```python
+# Register an endpoint
+endpoint = client.webhooks.create(
+    url="https://mystore.com/webhooks/paybridge",
+    events=["payment.succeeded", "payment.failed"],
+)
+
+# Verify a webhook signature (no client instance needed)
+from paybridge_np.resources.webhooks import WebhooksResource
+
+event = WebhooksResource.construct_event(
+    body=raw_body,
+    signature=request.headers["X-PayBridge-Signature"],
+    secret="whsec_...",
+)
+```
+
+## Billing (Subscriptions)
+
+```python
+# Create a plan
+plan = client.plans.create({
+    "name": "Pro Monthly",
+    "amount": 99900,
+    "intervalUnit": "month",
+})
+
+# Create a customer
+customer = client.customers.create({
+    "name": "Sita Gurung",
+    "email": "sita@example.com",
+})
+
+# Subscribe
+subscription = client.subscriptions.create({
+    "customerId": customer["id"],
+    "planId": plan["id"],
+})
+
+# List invoices
+invoices = client.invoices.list(customer_id=customer["id"])
+```
+
+## Sandbox mode
+
+Use a sandbox API key (`sk_sandbox_...`) to test without real money. The SDK automatically routes to sandbox endpoints.
+
+## Error handling
+
+```python
+from paybridge_np import PayBridgeError, AuthenticationError
+
+try:
+    session = client.checkout.create({...})
+except AuthenticationError:
+    print("Invalid API key")
+except PayBridgeError as e:
+    print(e, e.status_code)
+```
+
+## Context manager
+
+```python
+with PayBridge(api_key="sk_live_...") as client:
+    session = client.checkout.create({...})
+# HTTP client is closed automatically
+```
+
+## Documentation
+
+- [API Reference](https://docs.paybridgenp.com)
+- [Dashboard](https://dashboard.paybridgenp.com)
+- [Guides](https://docs.paybridgenp.com/guides/sandbox-testing)
+- [Discord](https://discord.gg/aquta4JwJt)
+
+## License
+
+MIT

paybridge_np-0.1.0/README.md

@@ -0,0 +1,136 @@
+# paybridge-np
+
+Official Python SDK for the [PayBridgeNP](https://paybridgenp.com) payment gateway. Accept eSewa, Khalti, and ConnectIPS through a single API.
+
+## Installation
+
+```bash
+pip install paybridge-np
+```
+
+## Quick start
+
+```python
+from paybridge_np import PayBridge
+
+client = PayBridge(api_key="sk_live_...")  # from dashboard.paybridgenp.com
+
+# Create a checkout session
+session = client.checkout.create({
+    "amount": 250000,        # NPR 2,500 in paisa
+    "currency": "NPR",
+    "returnUrl": "https://mystore.com/success",
+    "cancelUrl": "https://mystore.com/cart",
+    "metadata": {"orderId": "ORD-7842"},
+    "customer": {
+        "name": "Ram Shrestha",
+        "email": "ram@example.com",
+        "phone": "9841000000",
+    },
+})
+
+# Redirect customer to hosted checkout
+# session["checkout_url"] => https://paybridgenp.com/checkout/cs_xxx
+```
+
+## Payments
+
+```python
+# List payments
+result = client.payments.list(limit=20)
+payments = result["data"]
+
+# Get a single payment
+payment = client.payments.retrieve("pay_xxx")
+```
+
+## Refunds
+
+```python
+refund = client.refunds.create({
+    "paymentId": "pay_xxx",
+    "amount": 100000,  # NPR 1,000 in paisa
+    "reason": "customer_request",
+})
+```
+
+## Webhooks
+
+```python
+# Register an endpoint
+endpoint = client.webhooks.create(
+    url="https://mystore.com/webhooks/paybridge",
+    events=["payment.succeeded", "payment.failed"],
+)
+
+# Verify a webhook signature (no client instance needed)
+from paybridge_np.resources.webhooks import WebhooksResource
+
+event = WebhooksResource.construct_event(
+    body=raw_body,
+    signature=request.headers["X-PayBridge-Signature"],
+    secret="whsec_...",
+)
+```
+
+## Billing (Subscriptions)
+
+```python
+# Create a plan
+plan = client.plans.create({
+    "name": "Pro Monthly",
+    "amount": 99900,
+    "intervalUnit": "month",
+})
+
+# Create a customer
+customer = client.customers.create({
+    "name": "Sita Gurung",
+    "email": "sita@example.com",
+})
+
+# Subscribe
+subscription = client.subscriptions.create({
+    "customerId": customer["id"],
+    "planId": plan["id"],
+})
+
+# List invoices
+invoices = client.invoices.list(customer_id=customer["id"])
+```
+
+## Sandbox mode
+
+Use a sandbox API key (`sk_sandbox_...`) to test without real money. The SDK automatically routes to sandbox endpoints.
+
+## Error handling
+
+```python
+from paybridge_np import PayBridgeError, AuthenticationError
+
+try:
+    session = client.checkout.create({...})
+except AuthenticationError:
+    print("Invalid API key")
+except PayBridgeError as e:
+    print(e, e.status_code)
+```
+
+## Context manager
+
+```python
+with PayBridge(api_key="sk_live_...") as client:
+    session = client.checkout.create({...})
+# HTTP client is closed automatically
+```
+
+## Documentation
+
+- [API Reference](https://docs.paybridgenp.com)
+- [Dashboard](https://dashboard.paybridgenp.com)
+- [Guides](https://docs.paybridgenp.com/guides/sandbox-testing)
+- [Discord](https://discord.gg/aquta4JwJt)
+
+## License
+
+MIT

paybridge_np-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling<1.22"]
+build-backend = "hatchling.build"
+
+[project]
+name = "paybridge-np"
+version = "0.1.0"
+description = "Official Python SDK for the PayBridgeNP payment gateway - accept eSewa, Khalti, and ConnectIPS through a single API"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [{ name = "PayBridgeNP", email = "support@paybridgenp.com" }]
+keywords = [
+    "paybridge",
+    "nepal",
+    "payments",
+    "esewa",
+    "khalti",
+    "connectips",
+    "payment-gateway",
+    "nepal-payments",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.24.0"]
+
+[project.urls]
+Homepage = "https://paybridgenp.com"
+Documentation = "https://docs.paybridgenp.com"
+Repository = "https://github.com/paybridgenp/paybridgenp-python-sdk"
+Issues = "https://github.com/paybridgenp/paybridgenp-python-sdk/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/paybridge_np"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

paybridge_np-0.1.0/src/paybridge_np/__init__.py

@@ -0,0 +1,26 @@
+"""Official Python SDK for the PayBridgeNP payment gateway."""
+
+from .client import PayBridge
+from .errors import (
+    PayBridgeError,
+    AuthenticationError,
+    InvalidRequestError,
+    NotFoundError,
+    RateLimitError,
+    ConnectionError as PayBridgeConnectionError,
+    SignatureVerificationError,
+)
+
+SDK_VERSION = "0.1.0"
+
+__all__ = [
+    "PayBridge",
+    "PayBridgeError",
+    "AuthenticationError",
+    "InvalidRequestError",
+    "NotFoundError",
+    "RateLimitError",
+    "PayBridgeConnectionError",
+    "SignatureVerificationError",
+    "SDK_VERSION",
+]

paybridge_np-0.1.0/src/paybridge_np/client.py

@@ -0,0 +1,112 @@
+"""Main PayBridge client."""
+
+from __future__ import annotations
+
+from .http import HttpClient
+from .resources.checkout import CheckoutResource
+from .resources.payments import PaymentsResource
+from .resources.refunds import RefundsResource
+from .resources.webhooks import WebhooksResource
+from .resources.plans import PlansResource
+from .resources.customers import CustomersResource
+from .resources.subscriptions import SubscriptionsResource
+from .resources.invoices import InvoicesResource
+
+
+class PayBridge:
+    """PayBridgeNP API client.
+
+    Usage::
+
+        from paybridge_np import PayBridge
+
+        client = PayBridge(api_key="sk_live_...")
+        session = client.checkout.create({
+            "amount": 250000,
+            "returnUrl": "https://mystore.com/success",
+        })
+    """
+
+    # Static webhook utility -- no instance required for signature verification.
+    webhooks_static = WebhooksResource()
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str | None = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
+    ) -> None:
+        self._http = HttpClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+        self._checkout: CheckoutResource | None = None
+        self._payments: PaymentsResource | None = None
+        self._refunds: RefundsResource | None = None
+        self._webhooks: WebhooksResource | None = None
+        self._plans: PlansResource | None = None
+        self._customers: CustomersResource | None = None
+        self._subscriptions: SubscriptionsResource | None = None
+        self._invoices: InvoicesResource | None = None
+
+    @property
+    def checkout(self) -> CheckoutResource:
+        if self._checkout is None:
+            self._checkout = CheckoutResource(self._http)
+        return self._checkout
+
+    @property
+    def payments(self) -> PaymentsResource:
+        if self._payments is None:
+            self._payments = PaymentsResource(self._http)
+        return self._payments
+
+    @property
+    def refunds(self) -> RefundsResource:
+        if self._refunds is None:
+            self._refunds = RefundsResource(self._http)
+        return self._refunds
+
+    @property
+    def webhooks(self) -> WebhooksResource:
+        if self._webhooks is None:
+            self._webhooks = WebhooksResource(self._http)
+        return self._webhooks
+
+    @property
+    def plans(self) -> PlansResource:
+        if self._plans is None:
+            self._plans = PlansResource(self._http)
+        return self._plans
+
+    @property
+    def customers(self) -> CustomersResource:
+        if self._customers is None:
+            self._customers = CustomersResource(self._http)
+        return self._customers
+
+    @property
+    def subscriptions(self) -> SubscriptionsResource:
+        if self._subscriptions is None:
+            self._subscriptions = SubscriptionsResource(self._http)
+        return self._subscriptions
+
+    @property
+    def invoices(self) -> InvoicesResource:
+        if self._invoices is None:
+            self._invoices = InvoicesResource(self._http)
+        return self._invoices
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._http.close()
+
+    def __enter__(self) -> PayBridge:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

paybridge_np-0.1.0/src/paybridge_np/errors.py

@@ -0,0 +1,74 @@
+"""PayBridgeNP SDK error types."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class PayBridgeError(Exception):
+    """Base error for all PayBridgeNP API errors."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int = 0,
+        code: str = "api_error",
+        raw: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.raw = raw
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": type(self).__name__,
+            "message": str(self),
+            "code": self.code,
+            "status_code": self.status_code,
+            "raw": self.raw,
+        }
+
+
+class AuthenticationError(PayBridgeError):
+    def __init__(self, message: str, raw: dict[str, Any] | None = None) -> None:
+        super().__init__(message, 401, "authentication_error", raw)
+
+
+class InvalidRequestError(PayBridgeError):
+    def __init__(self, message: str, raw: dict[str, Any] | None = None) -> None:
+        super().__init__(message, 400, "invalid_request_error", raw)
+
+
+class NotFoundError(PayBridgeError):
+    def __init__(self, message: str, raw: dict[str, Any] | None = None) -> None:
+        super().__init__(message, 404, "not_found_error", raw)
+
+
+class RateLimitError(PayBridgeError):
+    def __init__(self, message: str, raw: dict[str, Any] | None = None) -> None:
+        super().__init__(message, 429, "rate_limit_error", raw)
+
+
+class ConnectionError(PayBridgeError):
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Connection error: {message}", 0, "connection_error")
+
+
+class SignatureVerificationError(PayBridgeError):
+    def __init__(self, message: str = "Webhook signature verification failed") -> None:
+        super().__init__(message, 0, "signature_verification_error")
+
+
+def create_error(
+    message: str, status_code: int, raw: dict[str, Any] | None
+) -> PayBridgeError:
+    if status_code == 401:
+        return AuthenticationError(message, raw)
+    if status_code == 404:
+        return NotFoundError(message, raw)
+    if status_code in (400, 422):
+        return InvalidRequestError(message, raw)
+    if status_code == 429:
+        return RateLimitError(message, raw)
+    return PayBridgeError(message, status_code, "api_error", raw)

paybridge_np-0.1.0/src/paybridge_np/http.py

@@ -0,0 +1,89 @@
+"""HTTP client with retries and exponential backoff."""
+
+from __future__ import annotations
+
+import random
+import time
+from typing import Any
+
+import httpx
+
+from .errors import PayBridgeError, ConnectionError, create_error
+
+DEFAULT_BASE_URL = "https://api.paybridgenp.com"
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_MAX_RETRIES = 2
+RETRY_STATUSES = {500, 502, 503, 504}
+INITIAL_BACKOFF_S = 0.5
+
+
+def _backoff(attempt: int) -> float:
+    return INITIAL_BACKOFF_S * (2 ** (attempt - 1)) + random.random() * 0.1
+
+
+class HttpClient:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str | None = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
+    ) -> None:
+        self._base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout or DEFAULT_TIMEOUT
+        self._max_retries = max_retries if max_retries is not None else DEFAULT_MAX_RETRIES
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            timeout=self._timeout,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "PayBridgeNP-Python/0.1.0",
+            },
+        )
+
+    def request(self, method: str, path: str, json: Any = None) -> Any:
+        attempt = 0
+        while True:
+            attempt += 1
+            try:
+                resp = self._client.request(method, path, json=json)
+            except httpx.HTTPError as exc:
+                if attempt > self._max_retries:
+                    raise ConnectionError(str(exc)) from exc
+                time.sleep(_backoff(attempt))
+                continue
+
+            if resp.is_success:
+                return resp.json()
+
+            if resp.status_code in RETRY_STATUSES and attempt <= self._max_retries:
+                retry_after = resp.headers.get("Retry-After")
+                delay = float(retry_after) if retry_after else _backoff(attempt)
+                time.sleep(delay)
+                continue
+
+            raw: dict[str, Any] | None = None
+            try:
+                raw = resp.json()
+            except Exception:
+                pass
+
+            message = raw.get("error", f"HTTP {resp.status_code}") if raw and isinstance(raw.get("error"), str) else f"HTTP {resp.status_code}"
+            raise create_error(message, resp.status_code, raw)
+
+    def get(self, path: str) -> Any:
+        return self.request("GET", path)
+
+    def post(self, path: str, json: Any) -> Any:
+        return self.request("POST", path, json=json)
+
+    def patch(self, path: str, json: Any) -> Any:
+        return self.request("PATCH", path, json=json)
+
+    def delete(self, path: str) -> Any:
+        return self.request("DELETE", path)
+
+    def close(self) -> None:
+        self._client.close()