python-myanmar-payments 4.0.0a1__py3-none-any.whl

python_myanmar_payments/yoma_mmqr.py

@@ -0,0 +1,526 @@
+"""Yoma Bank MMQR: QR payments, status checks and callbacks."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import inspect
+import re
+import threading
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Any, ClassVar, cast
+
+import httpx
+
+from ._amount import AmountInput, to_amount
+from ._cache import AsyncTokenCache, MemoryTokenCache, TokenCache
+from ._callback import CallbackRequest, lossless_body
+from ._errors import ApiError, SignatureVerificationError
+from ._http import (
+    DEFAULT_TIMEOUT,
+    AsyncGateway,
+    GatewayResponse,
+    HttpRequest,
+    SyncGateway,
+    form_request,
+    json_request,
+)
+from ._json import LosslessObject, to_plain_object
+from ._results import PaymentCallback, PaymentStatusResult, QrPayment
+from ._status import PaymentStatus, resolve_status
+from ._support import (
+    EnvSource,
+    config_of,
+    default_env,
+    env_first,
+    env_sandbox,
+    hmac_sha256_hex,
+    optional_setting,
+    require_setting,
+    safe_equal,
+    sandbox_flag,
+    sha256_hex,
+    trim_url,
+    utc_now,
+)
+from ._validate import AmountRule, Validator
+from ._values import get, is_nested, optional, trimmed
+
+__all__ = [
+    "AsyncYomaMmqr",
+    "YomaMmqr",
+    "YomaMmqrConfig",
+    "YomaMmqrPaymentData",
+]
+
+
+class YomaMmqrConfig:
+    """Yoma MMQR credentials and endpoints.
+
+    A missing credential raises a :class:`~python_myanmar_payments.ConfigurationError`.
+    """
+
+    SANDBOX_URL: ClassVar[str] = "https://devapi.yomabank.net"
+    PRODUCTION_URL: ClassVar[str] = "https://paymenthubapi.yomabank.com"
+    DEFAULT_API_VERSION: ClassVar[str] = "v1rc"
+
+    merchant_id: str
+    """The merchant ID Yoma issued."""
+    client_id: str
+    """The OAuth client ID."""
+    client_secret: str
+    """The OAuth client secret."""
+    webhook_hash_key: str
+    """The hash key Yoma issued for verifying callbacks."""
+    webhook_secret: str | None
+    """The secret you shared with Yoma; when set, callbacks must carry it in
+    ``X-Webhook-Secret``."""
+    sandbox: bool
+    """Whether the UAT payment hub is used."""
+    base_url: str
+    """The base URL in use."""
+    api_version: str
+    """The ``{version}`` segment of the API paths in use."""
+
+    def __init__(
+        self,
+        *,
+        merchant_id: str = "",
+        client_id: str = "",
+        client_secret: str = "",
+        webhook_hash_key: str = "",
+        webhook_secret: str | None = None,
+        sandbox: bool | str = True,
+        base_url: str | None = None,
+        api_version: str | None = None,
+    ) -> None:
+        self.merchant_id = require_setting("yoma_mmqr", "merchant_id", merchant_id)
+        self.client_id = require_setting("yoma_mmqr", "client_id", client_id)
+        self.client_secret = require_setting("yoma_mmqr", "client_secret", client_secret)
+        self.webhook_hash_key = require_setting("yoma_mmqr", "webhook_hashkey", webhook_hash_key)
+        self.webhook_secret = optional_setting(webhook_secret)
+        self.sandbox = sandbox = sandbox_flag(sandbox)
+        self.base_url = trim_url(
+            optional_setting(base_url) or (self.SANDBOX_URL if sandbox else self.PRODUCTION_URL)
+        )
+        self.api_version = optional_setting(api_version) or self.DEFAULT_API_VERSION
+
+    @classmethod
+    def from_env(cls, env: EnvSource | None = None) -> YomaMmqrConfig:
+        """Reads the ``YOMA_MMQR_*`` environment variables.
+
+        ``YOMA_MMQR_MERCHANT_ID``, ``YOMA_MMQR_CLIENT_ID``,
+        ``YOMA_MMQR_CLIENT_SECRET``, ``YOMA_MMQR_WEBHOOK_HASHKEY``,
+        ``YOMA_MMQR_WEBHOOK_SECRET``, ``YOMA_MMQR_SANDBOX``, ``YOMA_MMQR_BASE_URL``
+        and ``YOMA_MMQR_API_VERSION``. Defaults to ``os.environ``.
+        """
+        env = default_env() if env is None else env
+        return cls(
+            merchant_id=env_first(env, "YOMA_MMQR_MERCHANT_ID"),
+            client_id=env_first(env, "YOMA_MMQR_CLIENT_ID"),
+            client_secret=env_first(env, "YOMA_MMQR_CLIENT_SECRET"),
+            webhook_hash_key=env_first(env, "YOMA_MMQR_WEBHOOK_HASHKEY"),
+            webhook_secret=env_first(env, "YOMA_MMQR_WEBHOOK_SECRET"),
+            sandbox=env_sandbox(env, "YOMA_MMQR_SANDBOX"),
+            base_url=env_first(env, "YOMA_MMQR_BASE_URL"),
+            api_version=env_first(env, "YOMA_MMQR_API_VERSION"),
+        )
+
+    def __repr__(self) -> str:
+        return f"YomaMmqrConfig(merchant_id={self.merchant_id!r}, sandbox={self.sandbox!r})"
+
+
+@dataclass(kw_only=True)
+class YomaMmqrPaymentData:
+    """A Yoma MMQR order.
+
+    Yoma accepts each order number once; renew an expired QR with ``renew_qr()``.
+    Yoma documents no decimals, so amounts are whole kyat.
+    """
+
+    order_id: str
+    """Your unique order number, at most 20 characters."""
+    amount: AmountInput
+    """The amount in whole kyat, e.g. ``Amount.kyat(1000)`` or ``1000``."""
+    description: str
+    """Shown on the payment slip, at most 50 characters."""
+
+
+_STATUSES: Mapping[str, PaymentStatus] = {
+    "SUCCESS": PaymentStatus.SUCCESSFUL,
+    "PENDING": PaymentStatus.PENDING,
+    "FAILED": PaymentStatus.FAILED,
+    "FAIL": PaymentStatus.FAILED,
+}
+
+_LEADING_INT = re.compile(r"\s*([+-]?[0-9]+)")
+
+
+@dataclass(frozen=True)
+class _Call:
+    path: str
+    url: str
+    data: Mapping[str, Any]
+    allowed_errors: Sequence[str] = ()
+
+    def request(self, token: str) -> HttpRequest:
+        return json_request(self.url, self.data, {"Authorization": f"Bearer {token}"})
+
+
+class _YomaMmqrBase:
+    """What the sync and async Yoma clients share: requests, parsing and callbacks."""
+
+    QR_LIFETIME_SECONDS: ClassVar[int] = 120
+    """How long a generated QR stays payable, in seconds."""
+
+    config: YomaMmqrConfig
+    """The configuration in use."""
+
+    def __init__(self, config: YomaMmqrConfig | Mapping[str, Any]) -> None:
+        self.config = config_of(YomaMmqrConfig, config)
+
+    @staticmethod
+    def validate(data: YomaMmqrPaymentData) -> None:
+        """Checks the order against Yoma's documented limits.
+
+        Raises an :class:`~python_myanmar_payments.InvalidPaymentDataError`.
+        """
+        (
+            Validator()
+            .required("order_id", data.order_id)
+            .max("order_id", data.order_id, 20)
+            .amount("amount", data.amount, AmountRule("Yoma MMQR", 0))
+            .required("description", data.description)
+            .max("description", data.description, 50)
+            .validate()
+        )
+
+    def handle_callback(self, request: CallbackRequest) -> PaymentCallback:
+        """Verifies Yoma's payment callback.
+
+        The hash is HMAC-SHA256 of ``orderNumber=..&status=..`` keyed with the
+        order number followed by the webhook hash key.
+        """
+        payload = lossless_body(request)
+
+        if self.config.webhook_secret is not None and not safe_equal(
+            self.config.webhook_secret, request.header("X-Webhook-Secret") or ""
+        ):
+            raise SignatureVerificationError(
+                "Yoma MMQR callback has a missing or wrong X-Webhook-Secret header.",
+                to_plain_object(payload),
+            )
+
+        order_number = get(payload, "orderNumber")
+        status = trimmed(payload, "status")
+        expected = hmac_sha256_hex(
+            order_number + self.config.webhook_hash_key,
+            f"orderNumber={order_number}&status={status}",
+        )
+        if (
+            order_number == ""
+            or is_nested(payload.get("status"))
+            or not safe_equal(expected, get(payload, "hashValue").lower())
+        ):
+            raise SignatureVerificationError(
+                "Yoma MMQR callback hash verification failed.", to_plain_object(payload)
+            )
+
+        return PaymentCallback(
+            order_id=order_number,
+            status=resolve_status(_STATUSES, status.upper()),
+            gateway_status=status,
+            raw=to_plain_object(payload),
+        )
+
+    # --- Requests and results shared by both clients ------------------------------
+
+    def _api(self, path: str, data: Mapping[str, Any], allowed: Sequence[str] = ()) -> _Call:
+        url = f"{self.config.base_url}/payment-gateway/{self.config.api_version}/api/{path}"
+        return _Call(path, url, data, allowed)
+
+    def _checkout_call(self, data: YomaMmqrPaymentData) -> _Call:
+        self.validate(data)
+        return self._api(
+            "payment/checkout",
+            {
+                "merchantId": self.config.merchant_id,
+                "orderNumber": data.order_id,
+                "amount": str(to_amount(data.amount)),
+                "description": data.description,
+            },
+        )
+
+    @staticmethod
+    def _check_checkout(body: LosslessObject) -> None:
+        if body.get("checkOutStatus") is not True:
+            raise ApiError("Yoma MMQR did not confirm the checkout.", raw=to_plain_object(body))
+
+    def _renew_call(self, order_id: str) -> _Call:
+        return self._api(
+            "qr/generate", {"merchantId": self.config.merchant_id, "orderNumber": order_id}
+        )
+
+    def _qr_payment(self, order_id: str, body: LosslessObject) -> QrPayment:
+        qr_string = get(body, "qrString")
+        reference = get(body, "refLabel")
+        if qr_string == "" or reference == "":
+            raise ApiError("Yoma MMQR did not return a QR.", raw=to_plain_object(body))
+        return QrPayment(
+            order_id=order_id,
+            qr_image=qr_string,
+            expires_at=utc_now() + timedelta(seconds=self.QR_LIFETIME_SECONDS),
+            reference=reference,
+            raw=to_plain_object(body),
+        )
+
+    def _status_call(self, reference: str) -> _Call:
+        return self._api(
+            "payment/check-status",
+            {"merchantId": self.config.merchant_id, "refLabel": reference},
+            ["QR EXPIRED"],
+        )
+
+    @staticmethod
+    def _status_result(reference: str, body: LosslessObject) -> PaymentStatusResult:
+        if get(body, "errorCode") == "QR EXPIRED":
+            return PaymentStatusResult(
+                status=PaymentStatus.EXPIRED,
+                gateway_status="QR EXPIRED",
+                gateway_reference=reference,
+                raw=to_plain_object(body),
+            )
+        payment_status = trimmed(body, "paymentStatus")
+        return PaymentStatusResult(
+            status=resolve_status(_STATUSES, payment_status.upper()),
+            gateway_status=payment_status,
+            gateway_reference=get(body, "refLabel") or reference,
+            raw=to_plain_object(body),
+        )
+
+    @staticmethod
+    def _body(call: _Call, response: GatewayResponse) -> LosslessObject:
+        body = response.json()
+        error_code = get(body, "errorCode")
+        if not response.successful() or (
+            error_code != "" and error_code not in call.allowed_errors
+        ):
+            raise _api_error(call.path, response.status, body, error_code)
+        return body
+
+    def _token_request(self) -> HttpRequest:
+        credentials = f"{self.config.client_id}:{self.config.client_secret}"
+        encoded = base64.b64encode(credentials.encode()).decode()
+        return form_request(
+            f"{self.config.base_url}/token",
+            {"grant_type": "client_credentials"},
+            {"Authorization": f"Basic {encoded}"},
+        )
+
+    @staticmethod
+    def _token(response: GatewayResponse) -> tuple[str, int]:
+        """The access token and how many seconds to cache it."""
+        body = response.json()
+        token = get(body, "access_token")
+        if not response.successful() or token == "":
+            raise _api_error("token", response.status, body, get(body, "error"))
+        match = _LEADING_INT.match(get(body, "expires_in"))
+        expires_in = int(match.group(1)) if match else 0
+        return token, max(60, (expires_in if expires_in > 0 else 3600) - 60)
+
+    def _token_cache_key(self) -> str:
+        digest = sha256_hex(f"{self.config.base_url}|{self.config.client_id}")
+        return f"myanmar-payments.yoma-mmqr.token.{digest}"
+
+
+def _api_error(endpoint: str, status: int, body: LosslessObject, error_code: str) -> ApiError:
+    message = optional(body, "errorDescription") or optional(body, "error_description")
+    return ApiError(
+        f"Yoma MMQR {endpoint} failed: [{error_code}] {message or ''}".rstrip()
+        if error_code
+        else f"Yoma MMQR {endpoint} failed with HTTP {status}.",
+        gateway_code=error_code or None,
+        gateway_message=message or None,
+        http_status=status,
+        raw=to_plain_object(body),
+    )
+
+
+class YomaMmqr(_YomaMmqrBase, SyncGateway):
+    """Yoma Bank MMQR with a synchronous HTTP client.
+
+    QR payments, status checks and callbacks. Access tokens are cached in a
+    :class:`~python_myanmar_payments.TokenCache`; share the gateway (or pass a
+    shared cache) so they survive between calls. Use :class:`AsyncYomaMmqr` in
+    async code.
+    """
+
+    def __init__(
+        self,
+        config: YomaMmqrConfig | Mapping[str, Any],
+        *,
+        token_cache: TokenCache | None = None,
+        http_client: httpx.Client | None = None,
+        timeout: float | None = DEFAULT_TIMEOUT,
+    ) -> None:
+        super().__init__(config)
+        self._init_transport(http_client, timeout)
+        self._cache: TokenCache = token_cache if token_cache is not None else MemoryTokenCache()
+        self._token_lock = threading.Lock()
+
+    @classmethod
+    def from_env(
+        cls,
+        env: EnvSource | None = None,
+        *,
+        token_cache: TokenCache | None = None,
+        http_client: httpx.Client | None = None,
+        timeout: float | None = DEFAULT_TIMEOUT,
+    ) -> YomaMmqr:
+        """A gateway configured from the ``YOMA_MMQR_*`` environment variables."""
+        return cls(
+            YomaMmqrConfig.from_env(env),
+            token_cache=token_cache,
+            http_client=http_client,
+            timeout=timeout,
+        )
+
+    def initiate(self, data: YomaMmqrPaymentData) -> QrPayment:
+        """Checks the order out with Yoma and generates its first QR.
+
+        Call it once per order.
+        """
+        self._check_checkout(self._send(self._checkout_call(data)))
+        return self.renew_qr(data.order_id)
+
+    def renew_qr(self, order_id: str) -> QrPayment:
+        """Generates a new QR for an order that is already checked out.
+
+        Use it after the previous QR expired. The previous QR's reference stops
+        working.
+        """
+        return self._qr_payment(order_id, self._send(self._renew_call(order_id)))
+
+    def status(self, reference: str) -> PaymentStatusResult:
+        """Checks a QR's payment status by its reference (``QrPayment.reference``).
+
+        An expired QR reports ``expired``.
+        """
+        return self._status_result(reference, self._send(self._status_call(reference)))
+
+    def forget_token(self) -> None:
+        """Drops the cached access token, e.g. after rotating the client secret."""
+        self._cache.delete(self._token_cache_key())
+
+    def _send(self, call: _Call) -> LosslessObject:
+        response = self._transport.send(call.request(self._access_token()))
+        if response.status == 401:
+            self.forget_token()
+            response = self._transport.send(call.request(self._access_token()))
+        return self._body(call, response)
+
+    def _access_token(self) -> str:
+        key = self._token_cache_key()
+        cached = self._cache.get(key)
+        if isinstance(cached, str) and cached != "":
+            return cached
+        # Concurrent calls share one token request.
+        with self._token_lock:
+            cached = self._cache.get(key)
+            if isinstance(cached, str) and cached != "":
+                return cached
+            token, ttl = self._token(self._transport.send(self._token_request()))
+            self._cache.set(key, token, ttl)
+            return token
+
+
+AnyTokenCache = TokenCache | AsyncTokenCache
+
+
+class AsyncYomaMmqr(_YomaMmqrBase, AsyncGateway):
+    """Yoma Bank MMQR with an async HTTP client. The same API as :class:`YomaMmqr`, awaited.
+
+    ``token_cache`` takes a :class:`~python_myanmar_payments.TokenCache` or an
+    :class:`~python_myanmar_payments.AsyncTokenCache`.
+    """
+
+    def __init__(
+        self,
+        config: YomaMmqrConfig | Mapping[str, Any],
+        *,
+        token_cache: AnyTokenCache | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        timeout: float | None = DEFAULT_TIMEOUT,
+    ) -> None:
+        super().__init__(config)
+        self._init_transport(http_client, timeout)
+        self._cache: AnyTokenCache = token_cache if token_cache is not None else MemoryTokenCache()
+        self._token_lock = asyncio.Lock()
+
+    @classmethod
+    def from_env(
+        cls,
+        env: EnvSource | None = None,
+        *,
+        token_cache: AnyTokenCache | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        timeout: float | None = DEFAULT_TIMEOUT,
+    ) -> AsyncYomaMmqr:
+        """A gateway configured from the ``YOMA_MMQR_*`` environment variables."""
+        return cls(
+            YomaMmqrConfig.from_env(env),
+            token_cache=token_cache,
+            http_client=http_client,
+            timeout=timeout,
+        )
+
+    async def initiate(self, data: YomaMmqrPaymentData) -> QrPayment:
+        """Checks the order out with Yoma and generates its first QR. Call it once per order."""
+        self._check_checkout(await self._send(self._checkout_call(data)))
+        return await self.renew_qr(data.order_id)
+
+    async def renew_qr(self, order_id: str) -> QrPayment:
+        """Generates a new QR for an order that is already checked out."""
+        return self._qr_payment(order_id, await self._send(self._renew_call(order_id)))
+
+    async def status(self, reference: str) -> PaymentStatusResult:
+        """Checks a QR's payment status by its reference. An expired QR reports ``expired``."""
+        return self._status_result(reference, await self._send(self._status_call(reference)))
+
+    async def forget_token(self) -> None:
+        """Drops the cached access token, e.g. after rotating the client secret."""
+        await _resolve(self._cache.delete(self._token_cache_key()))
+
+    async def _send(self, call: _Call) -> LosslessObject:
+        response = await self._transport.send(call.request(await self._access_token()))
+        if response.status == 401:
+            await self.forget_token()
+            response = await self._transport.send(call.request(await self._access_token()))
+        return self._body(call, response)
+
+    async def _cached_token(self, key: str) -> str | None:
+        cached = await _resolve(self._cache.get(key))
+        return cached if isinstance(cached, str) and cached != "" else None
+
+    async def _access_token(self) -> str:
+        key = self._token_cache_key()
+        cached = await self._cached_token(key)
+        if cached is not None:
+            return cached
+        # Concurrent calls share one token request.
+        async with self._token_lock:
+            cached = await self._cached_token(key)
+            if cached is not None:
+                return cached
+            token, ttl = self._token(await self._transport.send(self._token_request()))
+            await _resolve(self._cache.set(key, token, ttl))
+            return token
+
+
+async def _resolve(value: Any) -> Any:
+    """Awaits ``value`` when a cache method returned an awaitable."""
+    if inspect.isawaitable(value):
+        return await cast("Any", value)
+    return value

python_myanmar_payments-4.0.0a1.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.5
+Name: python-myanmar-payments
+Version: 4.0.0a1
+Summary: Python SDK for Myanmar payment gateways: KBZ Pay, Wave Money, AYA Pay, Yoma MMQR and CyberSource. Typed requests and results, exact amounts, sync and async clients.
+Project-URL: Homepage, https://laranex.vercel.app/python-myanmar-payments
+Project-URL: Documentation, https://laranex.vercel.app/python-myanmar-payments
+Project-URL: Repository, https://github.com/laranex/python-myanmar-payments
+Project-URL: Issues, https://github.com/laranex/python-myanmar-payments/issues
+Project-URL: Changelog, https://github.com/laranex/python-myanmar-payments/blob/dev/CHANGELOG.md
+Author-email: Nay Thu Khant <naythukhant644@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Keywords: aya-pay,cybersource,kbzpay,laranex,mmqr,myanmar,payment-gateway,payments,python-myanmar-payments,wave-money,wavepay,yoma
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25
+Description-Content-Type: text/markdown
+
+# Python Myanmar Payments
+
+[![PyPI](https://img.shields.io/pypi/v/python-myanmar-payments.svg?style=flat-square)](https://pypi.org/project/python-myanmar-payments/)
+[![Tests](https://github.com/laranex/python-myanmar-payments/actions/workflows/tests.yml/badge.svg)](https://github.com/laranex/python-myanmar-payments/actions/workflows/tests.yml)
+[![Python](https://img.shields.io/pypi/pyversions/python-myanmar-payments.svg?style=flat-square)](https://pypi.org/project/python-myanmar-payments/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE.md)
+
+Python SDK for Myanmar payment gateways: KBZ Pay, Wave Money, AYA Pay, Yoma MMQR and CyberSource. Typed requests and results, exact amounts, sync and async clients. Built for humans and AI agents.
+
+## Documentation
+
+Full documentation, including installation, usage and the AI agent skill, lives at **[laranex.vercel.app/python-myanmar-payments](https://laranex.vercel.app/python-myanmar-payments)**.

python_myanmar_payments-4.0.0a1.dist-info/RECORD

@@ -0,0 +1,24 @@
+python_myanmar_payments/__init__.py,sha256=FI4lGJ1-7fFQ6B_AiLWmp1uHHHq18qfUHrcwQLxG20c,2633
+python_myanmar_payments/_amount.py,sha256=YoacvJ6_ZB9JM5exgkGPmzZM4IkZFR5e4cpvPv1iz5s,6720
+python_myanmar_payments/_cache.py,sha256=qxAGw7RjNWUWJQFbhcf-ROAv7oAXLtagUxKFn1EeLHM,2482
+python_myanmar_payments/_callback.py,sha256=xwrmWfFF5zXdtCyyfc--6ie3lCsq8Zu6Vurog2_lrd4,6678
+python_myanmar_payments/_errors.py,sha256=4QPyVdMSTig_-CZHb24j3JN93NNA6XQ59kigFrXHd6M,2841
+python_myanmar_payments/_facade.py,sha256=OieDF_OdpmQOmhvLWDNJ3-zgi9_4E9febEg3RcBkiGg,11194
+python_myanmar_payments/_http.py,sha256=vtjLdcO0o_ogfAeWisUAjhusO3sdCARwTclURHszceI,6272
+python_myanmar_payments/_json.py,sha256=FyN7J7fpHqfqa8GGlroqGTIOSR1K0JiYBouz20FGp0A,2608
+python_myanmar_payments/_results.py,sha256=Klf9U9pgG7ej5FnSJ-tJX5HSa0tSx3DCkscenZD4Ubk,9234
+python_myanmar_payments/_status.py,sha256=DRGkOrP1aE9hvt-vaH8f1rQcIo70IYZdqhhdaeGesrI,2326
+python_myanmar_payments/_support.py,sha256=iL5TO-IPN3sx3noWkvwbOZGvh2keSUIwyXVvzHogpDg,4971
+python_myanmar_payments/_validate.py,sha256=OYZokICLELcAEo42ODLYE4kNIn5FCVplTB0anirr0F8,6209
+python_myanmar_payments/_values.py,sha256=19LviQmhRbOatqjfGcZ7bi6GEparzUmUg0fz-V30Ok0,1953
+python_myanmar_payments/_version.py,sha256=0RKQvZCh46QOqtdJaDVgeyftE3UvgFVB8C9x4fITksU,24
+python_myanmar_payments/aya_pay.py,sha256=pUSC20v_Ay0t2cvmKsLe8XEjO5UneBRYE3_DFvj7xOg,18076
+python_myanmar_payments/cyber_source.py,sha256=WCzcv9vZ4SFm6OeI2A9G1DceBNjOdblvFDTt-pFwars,11457
+python_myanmar_payments/kbz_pay.py,sha256=TOzEZLbqgbSUXek75EXF_k6ZyALZiAZ5itogi_XgRYY,19873
+python_myanmar_payments/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_myanmar_payments/wave_money.py,sha256=cXyWOc6ix14-_GSAVMLzMvJvzvkgJX39RBbJSkTtbTw,16234
+python_myanmar_payments/yoma_mmqr.py,sha256=x1XDMWfjww83Kiq5OCrUgFc_Yy3mWF5_mj0mY5K9lS0,19486
+python_myanmar_payments-4.0.0a1.dist-info/METADATA,sha256=kb_a_m8p7THe2QxNUz4MhjvBu_gfb3C90ubKpWJOCSg,2643
+python_myanmar_payments-4.0.0a1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+python_myanmar_payments-4.0.0a1.dist-info/licenses/LICENSE.md,sha256=so-zBzmHxeh5dKArUhl-gYkpoljJXaw5TxWD9yOUVXU,1065
+python_myanmar_payments-4.0.0a1.dist-info/RECORD,,

python_myanmar_payments-4.0.0a1.dist-info/WHEEL

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

python_myanmar_payments-4.0.0a1.dist-info/licenses/LICENSE.md

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