zarpay 1.0.0__tar.gz

zarpay-1.0.0/LICENSE

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

zarpay-1.0.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: zarpay
+Version: 1.0.0
+Summary: Official Python SDK for the ZarPay payment gateway
+Home-page: https://github.com/zarpay/zarpay-python
+Author: ZarPay
+Author-email: support@zarpay.pk
+License: MIT
+Keywords: zarpay,payments,jazzcash,easypaisa,pakistan
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ZarPay Python SDK
+
+Official Python SDK for the [ZarPay](https://zarpay.pk) payment gateway.
+
+## Installation
+
+```bash
+pip install zarpay
+```
+
+## Quick Start
+
+```python
+from zarpay import ZarPay
+
+client = ZarPay("sk_sandbox_xxxxxxxxxxxxx")
+
+payment = client.payments.create(
+    merchant_order_id="ORD-123",
+    amount=1500,
+    channel_id=1,
+    customer_phone="03001234567",
+)
+
+print(payment["data"]["status"])  # 'completed' | 'processing' | 'failed'
+```
+
+## Usage
+
+### List Available Channels
+
+```python
+channels = client.channels.list()
+
+for ch in channels["data"]["channels"]:
+    print(f"{ch['id']}: {ch['wallet_type']}")
+```
+
+### Create a Payment
+
+```python
+payment = client.payments.create(
+    merchant_order_id="ORD-456",
+    amount=2500,
+    channel_id=1,
+    customer_phone="03001234567",
+    metadata={"customer_name": "Ahmed Khan"},
+    idempotency_key="unique-key-456",
+)
+
+if payment["success"]:
+    print("Payment completed:", payment["data"]["zarpay_id"])
+else:
+    print("Payment failed:", payment["data"]["failure_reason"])
+```
+
+### Get Payment Status
+
+```python
+# By ZarPay ID
+payment = client.payments.get("ZP_abc123def456")
+
+# By your order ID
+payment = client.payments.get_by_order_id("ORD-456")
+```
+
+### Verify Webhooks
+
+```python
+from zarpay import verify_webhook
+
+# In your webhook handler (e.g. Flask/Django)
+def webhook_handler(request):
+    try:
+        event = verify_webhook(
+            raw_body=request.body,
+            signature_header=request.headers["X-ZarPay-Signature"],
+            secret="whsec_your_webhook_secret",
+        )
+
+        if event["event"] == "payment.completed":
+            # Fulfill the order
+            pass
+        elif event["event"] == "payment.failed":
+            # Notify customer
+            pass
+
+        return HttpResponse(status=200)
+    except ValueError:
+        return HttpResponse(status=400)
+```
+
+### Error Handling
+
+```python
+from zarpay import ZarPay, ZarPayAPIError
+
+try:
+    payment = client.payments.create(...)
+except ZarPayAPIError as e:
+    print(e.status_code)  # 400, 401, 409, etc.
+    print(e.error)        # Human-readable error message
+```
+
+### Configuration
+
+```python
+client = ZarPay(
+    "sk_sandbox_xxx",
+    base_url="http://localhost:3000/api/v1",  # local development
+    timeout=60,                                # seconds
+)
+```
+
+## License
+
+MIT

zarpay-1.0.0/README.md

@@ -0,0 +1,117 @@
+# ZarPay Python SDK
+
+Official Python SDK for the [ZarPay](https://zarpay.pk) payment gateway.
+
+## Installation
+
+```bash
+pip install zarpay
+```
+
+## Quick Start
+
+```python
+from zarpay import ZarPay
+
+client = ZarPay("sk_sandbox_xxxxxxxxxxxxx")
+
+payment = client.payments.create(
+    merchant_order_id="ORD-123",
+    amount=1500,
+    channel_id=1,
+    customer_phone="03001234567",
+)
+
+print(payment["data"]["status"])  # 'completed' | 'processing' | 'failed'
+```
+
+## Usage
+
+### List Available Channels
+
+```python
+channels = client.channels.list()
+
+for ch in channels["data"]["channels"]:
+    print(f"{ch['id']}: {ch['wallet_type']}")
+```
+
+### Create a Payment
+
+```python
+payment = client.payments.create(
+    merchant_order_id="ORD-456",
+    amount=2500,
+    channel_id=1,
+    customer_phone="03001234567",
+    metadata={"customer_name": "Ahmed Khan"},
+    idempotency_key="unique-key-456",
+)
+
+if payment["success"]:
+    print("Payment completed:", payment["data"]["zarpay_id"])
+else:
+    print("Payment failed:", payment["data"]["failure_reason"])
+```
+
+### Get Payment Status
+
+```python
+# By ZarPay ID
+payment = client.payments.get("ZP_abc123def456")
+
+# By your order ID
+payment = client.payments.get_by_order_id("ORD-456")
+```
+
+### Verify Webhooks
+
+```python
+from zarpay import verify_webhook
+
+# In your webhook handler (e.g. Flask/Django)
+def webhook_handler(request):
+    try:
+        event = verify_webhook(
+            raw_body=request.body,
+            signature_header=request.headers["X-ZarPay-Signature"],
+            secret="whsec_your_webhook_secret",
+        )
+
+        if event["event"] == "payment.completed":
+            # Fulfill the order
+            pass
+        elif event["event"] == "payment.failed":
+            # Notify customer
+            pass
+
+        return HttpResponse(status=200)
+    except ValueError:
+        return HttpResponse(status=400)
+```
+
+### Error Handling
+
+```python
+from zarpay import ZarPay, ZarPayAPIError
+
+try:
+    payment = client.payments.create(...)
+except ZarPayAPIError as e:
+    print(e.status_code)  # 400, 401, 409, etc.
+    print(e.error)        # Human-readable error message
+```
+
+### Configuration
+
+```python
+client = ZarPay(
+    "sk_sandbox_xxx",
+    base_url="http://localhost:3000/api/v1",  # local development
+    timeout=60,                                # seconds
+)
+```
+
+## License
+
+MIT

zarpay-1.0.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"

zarpay-1.0.0/setup.cfg

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

zarpay-1.0.0/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="zarpay",
+    version="1.0.0",
+    description="Official Python SDK for the ZarPay payment gateway",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="ZarPay",
+    author_email="support@zarpay.pk",
+    url="https://github.com/zarpay/zarpay-python",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=["requests>=2.20.0"],
+    keywords=["zarpay", "payments", "jazzcash", "easypaisa", "pakistan"],
+    license="MIT",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

zarpay-1.0.0/zarpay/__init__.py

@@ -0,0 +1,22 @@
+"""
+ZarPay Python SDK
+
+Official SDK for integrating with the ZarPay payment gateway.
+
+Usage:
+    from zarpay import ZarPay
+
+    client = ZarPay("sk_sandbox_xxxxxxxxxxxxx")
+
+    payment = client.payments.create(
+        merchant_order_id="ORD-123",
+        amount=1500,
+        channel_id=1,
+        customer_phone="03001234567",
+    )
+"""
+
+from .client import ZarPay, ZarPayAPIError, verify_webhook
+
+__version__ = "1.0.0"
+__all__ = ["ZarPay", "ZarPayAPIError", "verify_webhook"]

zarpay-1.0.0/zarpay/client.py

@@ -0,0 +1,227 @@
+"""
+ZarPay Python SDK — Client implementation
+"""
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+import requests
+
+
+DEFAULT_BASE_URL = "https://zarpay.pk/api/v1"
+DEFAULT_TIMEOUT = 120
+
+
+class ZarPayAPIError(Exception):
+    """Raised when the ZarPay API returns an error response."""
+
+    def __init__(self, status_code: int, error: str, body: dict):
+        self.status_code = status_code
+        self.error = error
+        self.body = body
+        super().__init__(f"ZarPay API error ({status_code}): {error}")
+
+
+class PaymentsResource:
+    """Payment operations."""
+
+    def __init__(self, client: "ZarPay"):
+        self._client = client
+
+    def create(
+        self,
+        merchant_order_id: str,
+        amount: float,
+        channel_id: int,
+        customer_phone: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> dict:
+        """
+        Create a new payment.
+
+        Args:
+            merchant_order_id: Your unique order ID (max 100 chars)
+            amount: Amount in PKR (minimum 100)
+            channel_id: Channel ID from channels.list()
+            customer_phone: Customer phone (03XXXXXXXXX or +923XXXXXXXXX)
+            metadata: Optional custom key-value pairs
+            idempotency_key: Optional key to prevent duplicates
+
+        Returns:
+            Payment response dict with 'success' and 'data' keys
+
+        Raises:
+            ZarPayAPIError: If the API returns an error
+        """
+        body: Dict[str, Any] = {
+            "merchant_order_id": merchant_order_id,
+            "amount": amount,
+            "channel_id": channel_id,
+            "customer_phone": customer_phone,
+        }
+        if metadata is not None:
+            body["metadata"] = metadata
+        if idempotency_key is not None:
+            body["idempotency_key"] = idempotency_key
+
+        return self._client._request("POST", "/payments", json=body)
+
+    def get(self, zarpay_id: str) -> dict:
+        """
+        Get a payment by its ZarPay ID.
+
+        Args:
+            zarpay_id: The ZarPay-assigned payment ID (ZP_xxx)
+
+        Returns:
+            Payment response dict
+        """
+        return self._client._request("GET", f"/payments/{quote(zarpay_id, safe='')}")
+
+    def get_by_order_id(self, order_id: str) -> dict:
+        """
+        Get a payment by your merchant order ID.
+
+        Args:
+            order_id: Your merchant_order_id
+
+        Returns:
+            Payment response dict
+        """
+        return self._client._request(
+            "GET", f"/payments/by-order/{quote(order_id, safe='')}"
+        )
+
+
+class ChannelsResource:
+    """Channel operations."""
+
+    def __init__(self, client: "ZarPay"):
+        self._client = client
+
+    def list(self) -> dict:
+        """
+        List available payment channels for your project.
+
+        Returns:
+            Channels response with payment_methods, channels, and mode
+        """
+        return self._client._request("GET", "/channels")
+
+
+class ZarPay:
+    """
+    ZarPay API client.
+
+    Args:
+        api_key: Your ZarPay API key (sk_sandbox_... or sk_production_...)
+        base_url: API base URL (default: https://zarpay.pk/api/v1)
+        timeout: Request timeout in seconds (default: 120)
+
+    Example::
+
+        from zarpay import ZarPay
+
+        client = ZarPay("sk_sandbox_xxxxxxxxxxxxx")
+
+        # List channels
+        channels = client.channels.list()
+
+        # Create payment
+        payment = client.payments.create(
+            merchant_order_id="ORD-123",
+            amount=1500,
+            channel_id=1,
+            customer_phone="03001234567",
+        )
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = DEFAULT_TIMEOUT,
+    ):
+        if not api_key:
+            raise ValueError("ZarPay API key is required")
+
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update(
+            {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "zarpay-python/1.0.0",
+            }
+        )
+
+        self.payments = PaymentsResource(self)
+        self.channels = ChannelsResource(self)
+
+    def _request(self, method: str, path: str, **kwargs) -> dict:
+        url = f"{self._base_url}{path}"
+        response = self._session.request(
+            method, url, timeout=self._timeout, **kwargs
+        )
+        data = response.json()
+
+        if not response.ok and "error" in data:
+            raise ZarPayAPIError(response.status_code, data["error"], data)
+
+        return data
+
+
+def verify_webhook(
+    raw_body: bytes,
+    signature_header: str,
+    secret: str,
+    tolerance_sec: int = 300,
+) -> dict:
+    """
+    Verify a ZarPay webhook signature.
+
+    Args:
+        raw_body: The raw request body (bytes)
+        signature_header: The X-ZarPay-Signature header value
+        secret: Your webhook signing secret (whsec_...)
+        tolerance_sec: Max age in seconds (default: 300)
+
+    Returns:
+        The parsed webhook payload dict
+
+    Raises:
+        ValueError: If signature is invalid or timestamp is too old
+    """
+    parts = {}
+    for part in signature_header.split(","):
+        key, _, value = part.partition("=")
+        parts[key] = value
+
+    t = parts.get("t", "")
+    v1 = parts.get("v1", "")
+
+    if not t or not v1:
+        raise ValueError("Invalid X-ZarPay-Signature header format")
+
+    timestamp = int(t)
+    if abs(time.time() - timestamp) > tolerance_sec:
+        raise ValueError("Webhook timestamp too old — possible replay attack")
+
+    body_str = raw_body.decode("utf-8") if isinstance(raw_body, bytes) else raw_body
+    expected = hmac.new(
+        secret.encode("utf-8"),
+        f"{t}.{body_str}".encode("utf-8"),
+        digestmod=hashlib.sha256,
+    ).hexdigest()
+
+    if not hmac.compare_digest(expected, v1):
+        raise ValueError("Invalid webhook signature")
+
+    return json.loads(raw_body)

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

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: zarpay
+Version: 1.0.0
+Summary: Official Python SDK for the ZarPay payment gateway
+Home-page: https://github.com/zarpay/zarpay-python
+Author: ZarPay
+Author-email: support@zarpay.pk
+License: MIT
+Keywords: zarpay,payments,jazzcash,easypaisa,pakistan
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ZarPay Python SDK
+
+Official Python SDK for the [ZarPay](https://zarpay.pk) payment gateway.
+
+## Installation
+
+```bash
+pip install zarpay
+```
+
+## Quick Start
+
+```python
+from zarpay import ZarPay
+
+client = ZarPay("sk_sandbox_xxxxxxxxxxxxx")
+
+payment = client.payments.create(
+    merchant_order_id="ORD-123",
+    amount=1500,
+    channel_id=1,
+    customer_phone="03001234567",
+)
+
+print(payment["data"]["status"])  # 'completed' | 'processing' | 'failed'
+```
+
+## Usage
+
+### List Available Channels
+
+```python
+channels = client.channels.list()
+
+for ch in channels["data"]["channels"]:
+    print(f"{ch['id']}: {ch['wallet_type']}")
+```
+
+### Create a Payment
+
+```python
+payment = client.payments.create(
+    merchant_order_id="ORD-456",
+    amount=2500,
+    channel_id=1,
+    customer_phone="03001234567",
+    metadata={"customer_name": "Ahmed Khan"},
+    idempotency_key="unique-key-456",
+)
+
+if payment["success"]:
+    print("Payment completed:", payment["data"]["zarpay_id"])
+else:
+    print("Payment failed:", payment["data"]["failure_reason"])
+```
+
+### Get Payment Status
+
+```python
+# By ZarPay ID
+payment = client.payments.get("ZP_abc123def456")
+
+# By your order ID
+payment = client.payments.get_by_order_id("ORD-456")
+```
+
+### Verify Webhooks
+
+```python
+from zarpay import verify_webhook
+
+# In your webhook handler (e.g. Flask/Django)
+def webhook_handler(request):
+    try:
+        event = verify_webhook(
+            raw_body=request.body,
+            signature_header=request.headers["X-ZarPay-Signature"],
+            secret="whsec_your_webhook_secret",
+        )
+
+        if event["event"] == "payment.completed":
+            # Fulfill the order
+            pass
+        elif event["event"] == "payment.failed":
+            # Notify customer
+            pass
+
+        return HttpResponse(status=200)
+    except ValueError:
+        return HttpResponse(status=400)
+```
+
+### Error Handling
+
+```python
+from zarpay import ZarPay, ZarPayAPIError
+
+try:
+    payment = client.payments.create(...)
+except ZarPayAPIError as e:
+    print(e.status_code)  # 400, 401, 409, etc.
+    print(e.error)        # Human-readable error message
+```
+
+### Configuration
+
+```python
+client = ZarPay(
+    "sk_sandbox_xxx",
+    base_url="http://localhost:3000/api/v1",  # local development
+    timeout=60,                                # seconds
+)
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+zarpay/__init__.py
+zarpay/client.py
+zarpay.egg-info/PKG-INFO
+zarpay.egg-info/SOURCES.txt
+zarpay.egg-info/dependency_links.txt
+zarpay.egg-info/requires.txt
+zarpay.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

zarpay-1.0.0/zarpay.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.20.0

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

@@ -0,0 +1 @@
+zarpay