bpay 0.1.0__py3-none-any.whl

bpay/__init__.py

@@ -0,0 +1,5 @@
+from bpay.client import BPay
+
+__version__ = "0.1.0"
+
+__all__ = ["BPay"]

bpay/client.py

@@ -0,0 +1,157 @@
+from typing import Any
+
+from bpay.providers.bkash.callbacks import (
+    parse_agreement_callback,
+)
+from bpay.providers.bkash.payment_callbacks import (
+    parse_payment_callback,
+)
+from bpay.providers.registry import (
+    PROVIDERS,
+)
+from bpay.schemas.agreement import (
+    AgreementResponse,
+    CreateAgreementRequest,
+)
+from bpay.schemas.callback import (
+    AgreementCallback,
+)
+from bpay.schemas.payment import (
+    CreatePaymentRequest,
+    PaymentResponse,
+)
+from bpay.schemas.payment_callback import (
+    PaymentCallback,
+)
+from bpay.schemas.verification import (
+    PaymentVerificationResponse,
+)
+
+
+class BPay:
+    def __init__(
+        self,
+        provider: str,
+        **credentials: Any,
+    ) -> None:
+        provider_class = (
+            PROVIDERS.get(provider)
+        )
+
+        if provider_class is None:
+            supported = ", ".join(
+                PROVIDERS.keys()
+            )
+
+            raise ValueError(
+                f"Unsupported provider: "
+                f"{provider}. "
+                f"Supported providers: "
+                f"{supported}"
+            )
+
+        self.provider_name = (
+            provider
+        )
+
+        self.provider = (
+            provider_class(
+                **credentials
+            )
+        )
+
+    async def create_agreement(
+        self,
+        payload: CreateAgreementRequest,
+    ) -> AgreementResponse:
+        if not hasattr(
+            self.provider,
+            "create_agreement",
+        ):
+            raise NotImplementedError(
+                f"{self.provider_name} "
+                "does not support "
+                "agreement creation"
+            )
+
+        return await (
+            self.provider.create_agreement(
+                payload
+            )
+        )
+
+    async def create_payment(
+        self,
+        payload: CreatePaymentRequest,
+    ) -> PaymentResponse:
+        if not hasattr(
+            self.provider,
+            "create_payment",
+        ):
+            raise NotImplementedError(
+                f"{self.provider_name} "
+                "does not support "
+                "payment creation"
+            )
+
+        return await (
+            self.provider.create_payment(
+                payload
+            )
+        )
+
+    def parse_agreement_callback(
+        self,
+        params: dict[str, str],
+    ) -> AgreementCallback:
+        if (
+            self.provider_name
+            != "bkash"
+        ):
+            raise NotImplementedError(
+                f"{self.provider_name} "
+                "does not support "
+                "agreement callbacks yet"
+            )
+
+        return (
+            parse_agreement_callback(
+                params
+            )
+        )
+
+    def parse_payment_callback(
+        self,
+        params: dict[str, str],
+    ) -> PaymentCallback:
+        if self.provider_name != "bkash":
+            raise NotImplementedError(
+                f"{self.provider_name} "
+                "does not support "
+                "payment callbacks yet"
+            )
+
+        return parse_payment_callback(
+            params
+        )
+
+    async def verify_payment(
+        self,
+        payment_id: str,
+    ) -> PaymentVerificationResponse:
+        if not hasattr(
+            self.provider,
+            "verify_payment",
+        ):
+            raise NotImplementedError(
+                f"{self.provider_name} "
+                "does not support "
+                "payment verification"
+            )
+
+        return await (
+            self.provider.verify_payment(
+                payment_id
+            )
+        )
+

bpay/config/environments.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+
+class Environment(StrEnum):
+    SANDBOX = "sandbox"
+    PRODUCTION = "production"

bpay/exceptions.py

@@ -0,0 +1,52 @@
+class BPayError(Exception):
+    """Base exception for bpay."""
+
+
+class AuthenticationError(BPayError):
+    def __init__(
+        self,
+        provider: str,
+        message: str,
+        provider_code: str | None = None,
+    ) -> None:
+        self.provider = provider
+        self.provider_code = provider_code
+        self.message = message
+
+        super().__init__(self.__str__())
+
+    def __str__(self) -> str:
+        lines = [
+            f"[{self.provider} Authentication Error]",
+            f"Message: {self.message}",
+        ]
+
+        if self.provider_code:
+            lines.append(
+                f"Code: {self.provider_code}"
+            )
+
+        return "\n".join(lines)
+
+
+class AgreementError(
+    BPayError
+):
+    """Agreement workflow failed."""
+
+
+class ProviderAPIError(
+    BPayError
+):
+    def __init__(
+        self,
+        message: str,
+        provider_code: (
+            str | None
+        ) = None,
+    ) -> None:
+        self.provider_code = (
+            provider_code
+        )
+
+        super().__init__(message)

bpay/providers/base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+from bpay.schemas.payment import (
+    CreatePaymentRequest,
+    PaymentResponse,
+)
+
+
+class BaseProvider(ABC):
+    @abstractmethod
+    async def create_payment(
+        self,
+        payload: CreatePaymentRequest,
+    ) -> PaymentResponse:
+        pass

bpay/providers/bkash/agreement.py

@@ -0,0 +1,96 @@
+from typing import Any
+
+import httpx
+
+from bpay.exceptions import AgreementError
+from bpay.providers.bkash.auth import (
+    BkashAuth,
+)
+from bpay.providers.bkash.constants import (
+    BKASH_AGREEMENT_STATUS_MAP,
+)
+from bpay.schemas.agreement import (
+    AgreementResponse,
+    CreateAgreementRequest,
+)
+
+
+class BkashAgreement:
+    def __init__(
+        self,
+        auth: BkashAuth,
+        base_url: str,
+    ) -> None:
+        self.auth = auth
+        self.base_url = base_url
+
+    async def create(
+        self,
+        payload: CreateAgreementRequest,
+    ) -> AgreementResponse:
+        token = await self.auth.get_token()
+
+        url = (
+            f"{self.base_url}"
+            "/tokenized/checkout/create"
+        )
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": (
+                f"Bearer {token}"
+            ),
+            "X-APP-Key": (
+                self.auth.credentials.app_key
+            ),
+        }
+
+        request_body = {
+            "mode": "0000",
+            "payerReference": (
+                payload.customer_phone
+            ),
+            "callbackURL": (
+                payload.callback_url
+            ),
+        }
+
+        async with httpx.AsyncClient(
+            timeout=30
+        ) as client:
+            response = await client.post(
+                url,
+                json=request_body,
+                headers=headers,
+            )
+
+        response.raise_for_status()
+
+        data: dict[str, Any] = (
+            response.json()
+        )
+
+        if data.get("statusCode") != "0000":
+            raise AgreementError(
+                f"Agreement creation failed: "
+                f"{data}"
+            )
+
+        return AgreementResponse(
+            agreement_id="",
+            payment_id=str(
+                data["paymentID"]
+            ),
+            checkout_url=str(
+                data["bkashURL"]
+            ),
+            status=(
+                BKASH_AGREEMENT_STATUS_MAP[
+                    str(
+                        data[
+                            "agreementStatus"
+                        ]
+                    )
+                ]
+            ),
+        )

bpay/providers/bkash/auth.py

@@ -0,0 +1,87 @@
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import httpx
+
+from bpay.exceptions import AuthenticationError
+from bpay.providers.bkash.schemas import (
+    BkashCredentials,
+    BkashTokenResponse,
+)
+
+
+class BkashAuth:
+    BASE_URL = "https://tokenized.sandbox.bka.sh/v1.2.0-beta"
+
+    def __init__(
+        self,
+        credentials: BkashCredentials,
+        base_url: str
+    ) -> None:
+        self.credentials = credentials
+        self.base_url = base_url
+
+        self._token: BkashTokenResponse | None = None
+        self._expires_at: datetime | None = None
+
+    async def authenticate(
+        self,
+    ) -> BkashTokenResponse:
+        url = f"{self.base_url}/tokenized/checkout/token/grant"
+
+        headers = {
+            "Content-Type": "application/json",
+            "username": self.credentials.username,
+            "password": self.credentials.password,
+        }
+
+        payload = {
+            "app_key": self.credentials.app_key,
+            "app_secret": self.credentials.app_secret,
+        }
+
+        async with httpx.AsyncClient(timeout=30) as client:
+            response = await client.post(
+                url,
+                json=payload,
+                headers=headers,
+            )
+
+        response.raise_for_status()
+
+        data: dict[str, Any] = response.json()
+
+        if data.get("statusCode") != "0000":
+            raise AuthenticationError(
+                provider="bKash",
+                message=data.get(
+                    "statusMessage",
+                    "Authentication failed",
+                ),
+                provider_code=data.get(
+                    "statusCode"
+                ),
+            )
+
+        return BkashTokenResponse(
+            id_token=str(data["id_token"]),
+            refresh_token=str(data["refresh_token"]),
+            token_type=str(data["token_type"]),
+            expires_in=int(data["expires_in"]),
+        )
+
+    async def get_token(self) -> str:
+        if (
+            self._token is not None
+            and self._expires_at is not None
+            and datetime.now(UTC) < self._expires_at
+        ):
+            return self._token.id_token
+
+        token = await self.authenticate()
+
+        self._token = token
+
+        self._expires_at = datetime.now(UTC) + timedelta(seconds=token.expires_in - 60)
+
+        return token.id_token

bpay/providers/bkash/callbacks.py

@@ -0,0 +1,21 @@
+from bpay.schemas.callback import (
+    AgreementCallback,
+)
+from bpay.types import AgreementStatus
+
+STATUS_MAP = {
+    "success": AgreementStatus.ACTIVE,
+    "failure": AgreementStatus.FAILED,
+    "cancel": AgreementStatus.CANCELLED,
+}
+
+
+def parse_agreement_callback(
+    params: dict[str, str],
+) -> AgreementCallback:
+    return AgreementCallback(
+        payment_id=params["paymentID"],
+        status=STATUS_MAP[params["status"]],
+        signature=params["signature"],
+        agreement_id=params.get("agreementID"),
+    )

bpay/providers/bkash/constants.py

@@ -0,0 +1,17 @@
+from bpay.types import AgreementStatus
+
+BKASH_AGREEMENT_STATUS_MAP = {
+    "Initiated": AgreementStatus.INITIATED,
+    "Completed": AgreementStatus.ACTIVE,
+    "Cancelled": AgreementStatus.CANCELLED,
+    "Failure": AgreementStatus.FAILED,
+}
+
+BKASH_BASE_URLS = {
+    "sandbox": (
+        "https://tokenized.sandbox.bka.sh/v1.2.0-beta"
+    ),
+    "production": (
+        "https://tokenized.pay.bka.sh/v1.2.0-beta"
+    ),
+}

bpay/providers/bkash/payment.py

@@ -0,0 +1,103 @@
+from typing import Any
+
+import httpx
+
+from bpay.exceptions import (
+    ProviderAPIError,
+)
+from bpay.providers.bkash.auth import (
+    BkashAuth,
+)
+from bpay.schemas.payment import (
+    CreatePaymentRequest,
+    PaymentResponse,
+)
+from bpay.types import PaymentStatus
+
+
+class BkashPayment:
+    def __init__(
+        self,
+        auth: BkashAuth,
+        base_url: str,
+    ) -> None:
+        self.auth = auth
+        self.base_url = base_url
+
+    async def create(
+        self,
+        payload: CreatePaymentRequest,
+    ) -> PaymentResponse:
+        token = await self.auth.get_token()
+
+        url = (
+            f"{self.base_url}"
+            "/tokenized/checkout/create"
+        )
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": (
+                f"Bearer {token}"
+            ),
+            "X-APP-Key": (
+                self.auth.credentials.app_key
+            ),
+        }
+
+        request_body = {
+            "mode": "0011",
+            "callbackURL": (
+                payload.callback_url
+            ),
+            "amount": str(
+                payload.amount
+            ),
+            "currency": (
+                payload.currency
+            ),
+            "intent": (
+                payload.intent
+            ),
+            "merchantInvoiceNumber": (
+                payload.merchant_invoice_number
+            ),
+        }
+
+        if payload.payer_reference:
+            request_body[
+                "payerReference"
+            ] = (
+                payload.payer_reference
+            )
+
+        async with httpx.AsyncClient(
+            timeout=30
+        ) as client:
+            response = await client.post(
+                url,
+                json=request_body,
+                headers=headers,
+            )
+
+        response.raise_for_status()
+
+        data: dict[str, Any] = (
+            response.json()
+        )
+
+        if data.get("statusCode") != "0000":
+            raise ProviderAPIError(
+                f"Payment creation failed: "
+                f"{data}"
+            )
+
+        return PaymentResponse(
+            payment_id=str(
+                data["paymentID"]
+            ),
+            checkout_url=str(
+                data["bkashURL"]
+            ),
+            status=PaymentStatus.PENDING,
+        )

bpay/providers/bkash/payment_callbacks.py

@@ -0,0 +1,22 @@
+from bpay.schemas.payment_callback import (
+    PaymentCallback,
+)
+from bpay.types import PaymentStatus
+
+STATUS_MAP = {
+    "success": PaymentStatus.SUCCESS,
+    "failure": PaymentStatus.FAILED,
+    "cancel": PaymentStatus.CANCELLED,
+}
+
+
+def parse_payment_callback(
+    params: dict[str, str],
+) -> PaymentCallback:
+    return PaymentCallback(
+        payment_id=params["paymentID"],
+        status=STATUS_MAP[
+            params["status"]
+        ],
+        signature=params["signature"],
+    )

bpay/providers/bkash/provider.py

@@ -0,0 +1,117 @@
+from bpay.config.environments import (
+    Environment,
+)
+from bpay.providers.bkash.agreement import (
+    BkashAgreement,
+)
+from bpay.providers.bkash.auth import (
+    BkashAuth,
+)
+from bpay.providers.bkash.constants import (
+    BKASH_BASE_URLS,
+)
+from bpay.providers.bkash.payment import (
+    BkashPayment,
+)
+from bpay.providers.bkash.schemas import (
+    BkashCredentials,
+)
+from bpay.providers.bkash.verification import (
+    BkashVerification,
+)
+from bpay.schemas.agreement import (
+    AgreementResponse,
+    CreateAgreementRequest,
+)
+from bpay.schemas.payment import (
+    CreatePaymentRequest,
+    PaymentResponse,
+)
+from bpay.schemas.verification import (
+    PaymentVerificationResponse,
+)
+
+
+class BkashProvider:
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        app_key: str,
+        app_secret: str,
+        environment: str = "sandbox",
+    ) -> None:
+        credentials = (
+            BkashCredentials(
+                username=username,
+                password=password,
+                app_key=app_key,
+                app_secret=app_secret,
+            )
+        )
+
+        environment_enum = (
+            Environment(environment)
+        )
+
+        base_url = (
+            BKASH_BASE_URLS[
+                environment_enum.value
+            ]
+        )
+
+        auth = BkashAuth(
+            credentials=credentials,
+            base_url=base_url,
+        )
+
+        self.agreement_service = (
+            BkashAgreement(
+                auth=auth,
+                base_url=base_url,
+            )
+        )
+
+        self.payment_service = (
+            BkashPayment(
+                auth=auth,
+                base_url=base_url,
+            )
+        )
+
+        self.verification_service = (
+            BkashVerification(
+                auth=auth,
+                base_url=base_url,
+            )
+        )
+
+    async def create_agreement(
+        self,
+        payload: CreateAgreementRequest,
+    ) -> AgreementResponse:
+        return await (
+            self.agreement_service.create(
+                payload
+            )
+        )
+
+    async def create_payment(
+        self,
+        payload: CreatePaymentRequest,
+    ) -> PaymentResponse:
+        return await (
+            self.payment_service.create(
+                payload
+            )
+        )
+
+    async def verify_payment(
+        self,
+        payment_id: str,
+    ) -> PaymentVerificationResponse:
+        return await (
+            self.verification_service.verify_payment(
+                payment_id
+            )
+        )

bpay/providers/bkash/schemas.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+
+class BkashCredentials(BaseModel):
+    username: str
+    password: str
+    app_key: str
+    app_secret: str
+
+
+class BkashTokenResponse(BaseModel):
+    id_token: str
+    refresh_token: str
+    token_type: str
+    expires_in: int

bpay/providers/bkash/verification.py

@@ -0,0 +1,84 @@
+from typing import Any
+
+import httpx
+
+from bpay.exceptions import (
+    ProviderAPIError,
+)
+from bpay.providers.bkash.auth import (
+    BkashAuth,
+)
+from bpay.schemas.verification import (
+    PaymentVerificationResponse,
+)
+from bpay.types import PaymentStatus
+
+
+class BkashVerification:
+    def __init__(
+        self,
+        auth: BkashAuth,
+        base_url: str,
+    ) -> None:
+        self.auth = auth
+        self.base_url = base_url
+
+    async def verify_payment(
+        self,
+        payment_id: str,
+    ) -> PaymentVerificationResponse:
+        token = await self.auth.get_token()
+
+        url = (
+            f"{self.base_url}"
+            "/tokenized/checkout/payment/status"
+        )
+
+        headers = {
+            "Authorization": (
+                f"Bearer {token}"
+            ),
+            "X-APP-Key": (
+                self.auth.credentials.app_key
+            ),
+        }
+
+        payload = {
+            "paymentID": payment_id
+        }
+
+        async with httpx.AsyncClient(
+            timeout=30
+        ) as client:
+            response = await client.post(
+                url,
+                json=payload,
+                headers=headers,
+            )
+
+        response.raise_for_status()
+
+        data: dict[str, Any] = (
+            response.json()
+        )
+
+        if data.get("statusCode") != "0000":
+            raise ProviderAPIError(
+                f"Payment verification failed: "
+                f"{data}"
+            )
+
+        return (
+            PaymentVerificationResponse(
+                payment_id=str(
+                    data["paymentID"]
+                ),
+                trx_id=data.get("trxID"),
+                amount=float(
+                    data.get("amount", 0)
+                ),
+                status=(
+                    PaymentStatus.SUCCESS
+                ),
+            )
+        )

bpay/providers/registry.py

@@ -0,0 +1,5 @@
+from bpay.providers.bkash.provider import BkashProvider
+
+PROVIDERS = {
+    "bkash": BkashProvider,
+}

bpay/schemas/agreement.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+from bpay.types import AgreementStatus
+
+
+class CreateAgreementRequest(BaseModel):
+    customer_phone: str
+    callback_url: str
+
+
+class AgreementResponse(BaseModel):
+    agreement_id: str
+    payment_id: str
+    checkout_url: str
+    status: AgreementStatus

bpay/schemas/callback.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+from bpay.types import AgreementStatus
+
+
+class AgreementCallback(BaseModel):
+    payment_id: str
+    status: AgreementStatus
+    signature: str
+    agreement_id: str | None = None

bpay/schemas/payment.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+
+from bpay.types import PaymentStatus
+
+
+class CreatePaymentRequest(BaseModel):
+    amount: float
+    callback_url: str
+    merchant_invoice_number: str
+
+    currency: str = "BDT"
+    intent: str = "sale"
+
+    payer_reference: str | None = None
+
+
+class PaymentResponse(BaseModel):
+    payment_id: str
+    checkout_url: str
+    status: PaymentStatus

bpay/schemas/payment_callback.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+from bpay.types import PaymentStatus
+
+
+class PaymentCallback(BaseModel):
+    payment_id: str
+    status: PaymentStatus
+    signature: str

bpay/schemas/verification.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+from bpay.types import PaymentStatus
+
+
+class PaymentVerificationResponse(
+    BaseModel
+):
+    payment_id: str
+    trx_id: str | None = None
+    amount: float | None = None
+    status: PaymentStatus

bpay/transports/http.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+import httpx
+
+
+class HttpTransport:
+    def __init__(self) -> None:
+        self.client = httpx.AsyncClient(timeout=30)
+
+    async def post(
+        self,
+        url: str,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        return await self.client.post(url, **kwargs)

bpay/types.py

@@ -0,0 +1,21 @@
+from enum import StrEnum
+
+
+class PaymentStatus(StrEnum):
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class RefundStatus(StrEnum):
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILED = "failed"
+
+
+class AgreementStatus(StrEnum):
+    INITIATED = "initiated"
+    ACTIVE = "active"
+    FAILED = "failed"
+    CANCELLED = "cancelled"

bpay-0.1.0.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: bpay
+Version: 0.1.0
+Summary: Unified Python SDK for Bangladeshi payment gateways
+Project-URL: Homepage, https://github.com/thatsayon/bpay-python
+Project-URL: Repository, https://github.com/thatsayon/bpay-python
+Project-URL: Issues, https://github.com/thatsayon/bpay-python/issues
+Author: Ayon
+License: MIT
+License-File: LICENSE
+Keywords: bangladesh,bkash,nagad,payments,sslcommerz
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.13.4
+Description-Content-Type: text/markdown
+
+# bpay
+
+Unified Python SDK for Bangladeshi payment gateways.
+
+`bpay` provides a clean, typed, async-first developer experience for integrating Bangladeshi payment providers like bKash, Nagad, and SSLCommerz.
+
+---
+
+## Features
+
+- Async-first architecture
+- Typed request & response models
+- Sandbox & production environment support
+- Hosted checkout workflows
+- Agreement/tokenized checkout support
+- Payment callback parsing
+- Payment verification support
+- Provider abstraction layer
+- Modern Python packaging with `uv`
+
+---
+
+## Supported Providers
+
+| Provider | Status |
+|---|---|
+| bKash | In Progress |
+| Nagad | Planned |
+| SSLCommerz | Planned |
+
+---
+
+## Installation
+
+```bash
+pip install bpay
+```
+
+---
+
+## Quick Start
+
+### Create a One-Time Payment
+
+```python
+import asyncio
+
+from bpay import BPay
+from bpay.config.environments import (
+    Environment,
+)
+from bpay.schemas.payment import (
+    CreatePaymentRequest,
+)
+
+
+async def main() -> None:
+    client = BPay(
+        provider="bkash",
+        environment=Environment.SANDBOX,
+        username="YOUR_USERNAME",
+        password="YOUR_PASSWORD",
+        app_key="YOUR_APP_KEY",
+        app_secret="YOUR_APP_SECRET",
+    )
+
+    payment = await client.create_payment(
+        CreatePaymentRequest(
+            amount=100,
+            merchant_invoice_number="INV-1001",
+            callback_url=(
+                "https://yourdomain.com/callback"
+            ),
+        )
+    )
+
+    print(payment.checkout_url)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## Agreement / Tokenized Checkout
+
+Agreements allow merchants to create reusable customer payment authorizations for recurring or saved payments.
+
+### Create Agreement
+
+```python
+import asyncio
+
+from bpay import BPay
+from bpay.config.environments import (
+    Environment,
+)
+from bpay.schemas.agreement import (
+    CreateAgreementRequest,
+)
+
+
+async def main() -> None:
+    client = BPay(
+        provider="bkash",
+        environment=Environment.SANDBOX,
+        username="YOUR_USERNAME",
+        password="YOUR_PASSWORD",
+        app_key="YOUR_APP_KEY",
+        app_secret="YOUR_APP_SECRET",
+    )
+
+    agreement = await (
+        client.create_agreement(
+            CreateAgreementRequest(
+                customer_phone="017XXXXXXXX",
+                callback_url=(
+                    "https://yourdomain.com/callback"
+                ),
+            )
+        )
+    )
+
+    print(agreement.checkout_url)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## Callback Parsing
+
+### Payment Callback
+
+```python
+from bpay import BPay
+
+client = BPay(...)
+
+callback = client.parse_payment_callback(
+    {
+        "paymentID": "PAY123",
+        "status": "success",
+        "signature": "abc123",
+    }
+)
+
+print(callback.status)
+```
+
+---
+
+### Agreement Callback
+
+```python
+from bpay import BPay
+
+client = BPay(...)
+
+callback = (
+    client.parse_agreement_callback(
+        {
+            "paymentID": "PAY123",
+            "agreementID": "AGR123",
+            "status": "success",
+            "signature": "abc123",
+        }
+    )
+)
+
+print(callback.status)
+```
+
+---
+
+## Payment Verification
+
+```python
+verification = await client.verify_payment(
+    payment_id="PAY123"
+)
+
+print(verification.status)
+```
+
+---
+
+## Environments
+
+`bpay` supports both sandbox and production environments.
+
+### Sandbox
+
+```python
+from bpay.config.environments import (
+    Environment,
+)
+
+Environment.SANDBOX
+```
+
+### Production
+
+```python
+from bpay.config.environments import (
+    Environment,
+)
+
+Environment.PRODUCTION
+```
+
+---
+
+## Development
+
+### Setup
+
+```bash
+uv sync
+```
+
+### Run Checks
+
+```bash
+make check
+```
+
+### Run Tests
+
+```bash
+uv run pytest
+```
+
+---
+
+## Project Structure
+
+```text
+src/bpay/
+├── client.py
+├── exceptions.py
+├── config/
+├── providers/
+├── schemas/
+├── transports/
+└── types.py
+```
+
+---
+
+## Roadmap
+
+- Full bKash recurring payment workflow
+- Nagad integration
+- SSLCommerz integration
+- Refund support
+- Webhook signature verification
+- Automatic retry handling
+- Sync client support
+- Logging middleware
+
+---
+
+## License
+
+MIT License

bpay-0.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+bpay/__init__.py,sha256=L4D37QQavc_fb7ub3UdD6nN1V7ke3utYojGV8CGbOe8,72
+bpay/client.py,sha256=yYUpNvyrfLdPUdqrSDxMBmdUoCiyTnw2z7ohn5dUrDQ,3591
+bpay/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/exceptions.py,sha256=eNN79RSgY42tU-RJE4s69ZiR-m7fq1ZJYDhiutoJ_BU,1049
+bpay/types.py,sha256=KblekKPgCT0VW4CpUviw2PvHNDfeP2XX5XTQlCBuT-k,390
+bpay/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/config/environments.py,sha256=uhIAYD0o9y49_D2SmXhH_oy1TPJV83RHwOejbtvipW0,109
+bpay/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/providers/base.py,sha256=q2uS8o5o8o6_Jymdc3kf2w1AAr-SGKaNbuLOEeGUNAM,290
+bpay/providers/registry.py,sha256=ArWomtK-7tiLE5i-Mx4M2lhv9dTYSM4SbHfiP51ElDs,101
+bpay/providers/bkash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/providers/bkash/agreement.py,sha256=iMYt4lHv7NmqNo7lwAZ3abqjH70K_9waFZ1EJszFdsg,2191
+bpay/providers/bkash/auth.py,sha256=an9grQMvNs-2qM5S33i2LabSGK_ZRSvLNzJfxVhjeCI,2356
+bpay/providers/bkash/callbacks.py,sha256=bFCn-adHn4LdduWCkEEdmKWr_4IToO4wicQXerK4mjs,529
+bpay/providers/bkash/constants.py,sha256=d0Ig-J4aEdIN5dq9FQuQuWBYuiM8IeZIA-1ZVkcBVdg,421
+bpay/providers/bkash/payment.py,sha256=C8UH8dmDcy2FLtUKVLs-isky4kepZjbY-Qa_t5ySDPk,2313
+bpay/providers/bkash/payment_callbacks.py,sha256=1zw-ZWYsfBAWtPE3j7YE17baaYV9NEaj2_0tVlPRIkE,496
+bpay/providers/bkash/provider.py,sha256=x_sBk7k4d7tQ6-OY4PHcUbYqpx_u1U1YCgUe2nkTfAo,2559
+bpay/providers/bkash/schemas.py,sha256=_1uj-nyhYEGQPoNXk19I76TfsuT041RExrxBjN6ELGo,261
+bpay/providers/bkash/verification.py,sha256=LcTcCOcVDB2Kt4nVVjNwuXyNWxvty7BCJNY4HB_eOqI,1860
+bpay/providers/nagad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/providers/sslcommerz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/schemas/agreement.py,sha256=ChuUhHTAiKwomyPWjFdaPEB8Z-WYh3wQqv4erOdVElY,290
+bpay/schemas/callback.py,sha256=Iwn8tnOGBU0_kabeMjI0iYAuur7XrOavox7A4fXiXo8,212
+bpay/schemas/payment.py,sha256=rc1ko6RLZADFslktdPjDf_V3ZKjU_xl70De1ft2rC2Q,379
+bpay/schemas/payment_callback.py,sha256=FGUAHb-xAC-MZqGoDHxaxfKfn62bfTYI3kL9MmFpW9o,170
+bpay/schemas/verification.py,sha256=fwmQUH2hNbQG00JXnLFIE8Cqa-sgGWkK_fdgLIOr5eM,231
+bpay/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/transports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay/transports/http.py,sha256=39dppdUBvlS59auFh5S16_zBLpTvSQRw_H6YfcjMl4A,298
+bpay/webhooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bpay-0.1.0.dist-info/METADATA,sha256=JCMUSLo2LVG5_W0Wv_Qcu2su9S4iYraWchXm89eb9ko,5035
+bpay-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+bpay-0.1.0.dist-info/licenses/LICENSE,sha256=Tci2KBJuPGYHHw0o2VmR8mwmB4145ZIZ6S_Mp21z57o,1061
+bpay-0.1.0.dist-info/RECORD,,

bpay-0.1.0.dist-info/WHEEL

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

bpay-0.1.0.dist-info/licenses/LICENSE

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