python-myanmar-payments 4.0.0a1__tar.gz → 4.0.0a2__tar.gz

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/CHANGELOG.md

@@ -9,9 +9,9 @@ Initial release. The version number matches the other Laranex Myanmar payments p
 ### Added
 - Gateways: KBZ Pay (`pwa`, `qr`, `app`, `status`), Wave Money (`initiate`), AYA Payment Gateway (`services`, `initiate`, `status`, `verify_redirect`), Yoma MMQR (`initiate`, `renew_qr`, `status`, `forget_token`) and CyberSource Secure Acceptance (`initiate`); every gateway validates its payment data (`KbzPay.validate()` and so on) and verifies callbacks with `handle_callback`.
 - A sync and an async client for every gateway that calls an API (`KbzPay` / `AsyncKbzPay`, `WaveMoney` / `AsyncWaveMoney`, `AyaPay` / `AsyncAyaPay`, `YomaMmqr` / `AsyncYomaMmqr`), sharing one implementation of signing, validation and response parsing. `CyberSource` makes no network calls and serves both.
-- `httpx` is the only runtime dependency: pass your own `httpx.Client` / `httpx.AsyncClient` as `http_client`, or let the gateway create one with a 30 second `timeout` and close it with `close()` / `aclose()` or a `with` / `async with` block.
+- `httpx` is the only runtime dependency: pass your own `httpx.Client` / `httpx.AsyncClient` as `http_client`, or let the gateway create one with the config's `timeout_seconds` and close it with `close()` / `aclose()` or a `with` / `async with` block.
 - Exact `Amount` type (`Amount.kyat()`, `Amount.parse()`, `Amount.of()`) kept as decimal text, so amounts never pass through a float; payment data also takes a whole `int`, decimal text or a `Decimal`, and rejects floats. Decimals are accepted only where the gateway documents them (KBZ Pay up to 2 places, CyberSource any); every gateway except CyberSource is MMK only.
-- Typed payment data dataclasses (`KbzPayPaymentData`, `WaveMoneyPaymentData` with `WaveMoneyItem`, `AyaPayPaymentData`, `YomaMmqrPaymentData`, `CyberSourcePaymentData`) and a config class per gateway with `from_env()` (default `os.environ`), reading the same `*_SANDBOX`, credential and URL variables as the PHP, Laravel, Go and Node packages; a missing credential raises `ConfigurationError`. `sandbox` also takes text read like `*_SANDBOX` (`false`, `0`, `f`, `no` or `off` select production). Gateways, `MyanmarPayments` and `AsyncMyanmarPayments` take config objects or mappings of their keyword arguments; the facades build every gateway lazily, also from the environment.
+- Typed payment data dataclasses (`KbzPayPaymentData`, `WaveMoneyPaymentData` with `WaveMoneyItem`, `AyaPayPaymentData`, `YomaMmqrPaymentData`, `CyberSourcePaymentData`) and a config class per gateway with `from_env()` (default `os.environ`), reading the same credential, setting and URL variables as the PHP, Laravel, Go and Node packages; a missing setting raises `ConfigurationError`. Gateways, `MyanmarPayments` and `AsyncMyanmarPayments` take config objects or mappings of their keyword arguments; the facades build every gateway lazily, also from the environment.
 - Result classes: `RedirectPayment`, `FormPayment` (with `to_html()`), `QrPayment` (with `qr_image_data_uri()`) and `AppPayment` (with `to_dict()`); `PaymentCallback` (with a gateway-independent `PaymentStatus` and the `Acknowledgement` each gateway expects, in its `acknowledgement` attribute) and `PaymentStatusResult`.
 - `CallbackRequest(body=..., headers=..., query=...)` takes the raw body bytes, headers and query string from Django, Flask, FastAPI or any other framework; `CallbackRequest.from_json()` replays a stored callback. JSON numbers in callbacks are read without a float conversion, so signatures and amounts keep the gateway's exact text, and `raw` (like `parsed_body()`, `input()` and error `raw`) holds every JSON number as its exact text, e.g. `"1000.50"`.
 - Errors: `PaymentError` and its subclasses `InvalidPaymentDataError` (per-field `errors`), `ApiError` (`gateway_code`, `gateway_message`, `http_status`, `raw`, network errors chained as `__cause__`), `SignatureVerificationError` and `ConfigurationError`.
@@ -22,7 +22,10 @@ Initial release. The version number matches the other Laranex Myanmar payments p
 - AYA Pay reads a `payload` whose `+` signs became spaces in an unencoded return query string, with or without base64 padding; partial padding, other alphabets and payloads that are not UTF-8 are rejected.
 - Yoma MMQR caches its token under `myanmar-payments.yoma-mmqr.token.<sha256 of base URL|client id>`, the same key as the PHP, Go and Node SDKs, so services in different languages can share one cache.
 - Callback, return and cancel URLs only need to be valid absolute http or https URLs; there is no HTTPS-only rule (gateways may still require HTTPS in production).
-- Wave Money's sandbox is `https://preprodpayments.wavemoney.io:8107`, with checkout at `https://preprodpayments.wavemoney.io/authenticate`.
 - Fully typed (`py.typed`, `mypy --strict`).
 - Agent skill in `skills/python-myanmar-payments` so coding agents use the package correctly; install it with `npx skills add laranex/python-myanmar-payments`.
 - Requires Python 3.10 or higher.
+
+### Changed since the pre-releases
+
+- No sandbox switch: the sandbox setting (`sandbox`) and the `*_SANDBOX` variables are removed, and every gateway defaults to its production endpoints. Every other setting is required: the HTTP timeout (`timeout_seconds`, error key `timeout_in_seconds`, `MYANMAR_PAYMENTS_HTTP_TIMEOUT`) for every gateway that calls an API, Wave Money's `time_to_live_seconds` (error key `time_to_live_in_seconds`) and `merchant_name` (no `APP_NAME` fallback), Yoma MMQR's `api_version`, and CyberSource's `currency`, `locale` and `transaction_type` on each payment. A missing setting raises `ConfigurationError` naming it; a time setting that is not a whole number greater than 0 raises `The <gateway> configuration [<key>] must be a whole number greater than 0.` (`ConfigurationError(gateway, key, invalid=True)`). The `timeout` keyword argument of the gateways and facades, `DEFAULT_TIMEOUT` and the `SANDBOX_*` URL constants are removed. Upgrading: delete `*_SANDBOX`; to keep testing against UAT, set the URL overrides to the UAT URLs listed in the docs; set the newly required settings.

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-myanmar-payments
-Version: 4.0.0a1
+Version: 4.0.0a2
 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

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/skills/python-myanmar-payments/SKILL.md

@@ -23,7 +23,7 @@ Requires Python 3.10+ and depends only on `httpx`. Import everything from `pytho
 
 ## Configure
 
-`MyanmarPayments.from_env()` reads `KBZ_PAY_*`, `WAVE_MONEY_*`, `AYA_PAY_*` (or `AYA_PGW_*`), `YOMA_MMQR_*` and `CYBER_SOURCE_*` from `os.environ` (the same variables as the PHP, Go and Node SDKs). `sandbox` defaults to `True`; set `*_SANDBOX=false` (or `sandbox=False`) in production.
+`MyanmarPayments.from_env()` reads `KBZ_PAY_*`, `WAVE_MONEY_*`, `AYA_PAY_*` (or `AYA_PGW_*`), `YOMA_MMQR_*` and `CYBER_SOURCE_*` plus `MYANMAR_PAYMENTS_HTTP_TIMEOUT` from `os.environ` (the same variables as the PHP, Go and Node SDKs). Every setting except the URL overrides and Yoma's `YOMA_MMQR_WEBHOOK_SECRET` is required, including the HTTP timeout (`MYANMAR_PAYMENTS_HTTP_TIMEOUT`, seconds), `WAVE_MONEY_MERCHANT_NAME`, `WAVE_MONEY_TIME_TO_LIVE_IN_SECONDS` and `YOMA_MMQR_API_VERSION`. The URLs default to each gateway's production endpoints; to test against UAT, set the URL overrides (`KBZ_PAY_BASE_URL`, `KBZ_PAY_PWA_BASE_REDIRECT_URL`, `WAVE_MONEY_BASE_URL`, `WAVE_MONEY_AUTHENTICATE_URL`, `AYA_PAY_BASE_URL`, `YOMA_MMQR_BASE_URL`, `CYBER_SOURCE_BASE_URL`) to the UAT URLs, together with UAT credentials.
 
 ```python
 from python_myanmar_payments import MyanmarPayments
@@ -32,10 +32,10 @@ payments = MyanmarPayments.from_env()  # create once, share across requests
 kbz = payments.kbz_pay()  # also wave_money(), aya_pay(), yoma_mmqr(), cyber_source()
 ```
 
-- Or build one gateway: `KbzPay(KbzPayConfig(app_id=..., app_key=..., merchant_code=...))`, `KbzPay.from_env()` or `KbzPay(KbzPayConfig.from_env())`; in async code use `AsyncMyanmarPayments.from_env()` and `AsyncKbzPay`.
-- Or pass the settings directly: gateways and `MyanmarPayments(kbz_pay={"app_id": ..., "app_key": ..., "merchant_code": ...})` take config objects or mappings of their keyword arguments; a string `sandbox` such as `"false"` is read like the variable.
-- Options (keyword arguments): `http_client` (your own `httpx.Client` / `httpx.AsyncClient`) and `timeout` (seconds, default 30); close the clients the package created with `payments.close()` / `await payments.aclose()` or a `with` block. Yoma and the facades also take `token_cache` (any `TokenCache`, default `MemoryTokenCache`; back it with Redis when you run several processes).
-- A missing credential raises `ConfigurationError` (`gateway`, `key`).
+- Or build one gateway: `KbzPay(KbzPayConfig(app_id=..., app_key=..., merchant_code=..., timeout_seconds=30))`, `KbzPay.from_env()` or `KbzPay(KbzPayConfig.from_env())`; in async code use `AsyncMyanmarPayments.from_env()` and `AsyncKbzPay`.
+- Or pass the settings directly: gateways and `MyanmarPayments(kbz_pay={"app_id": ..., "app_key": ..., "merchant_code": ..., "timeout_seconds": 30})` take config objects or mappings of their keyword arguments; `timeout_seconds` and Wave's `time_to_live_seconds` take an `int` or integer text.
+- Options (keyword arguments): `http_client` (your own `httpx.Client` / `httpx.AsyncClient`) (it keeps its own timeout; without one the gateway creates a client with the config's `timeout_seconds`); close the clients the package created with `payments.close()` / `await payments.aclose()` or a `with` block. Yoma and the facades also take `token_cache` (any `TokenCache`, default `MemoryTokenCache`; back it with Redis when you run several processes).
+- A missing setting raises `ConfigurationError` (`gateway`, `key`), and a time setting that is not a whole number greater than 0 raises it too.
 
 ## Use
 
@@ -45,7 +45,7 @@ Amounts are `Amount.kyat(1000)`, `Amount.parse("1000.50")`, a whole `int`, decim
 
 ### Start a payment
 
-Each gateway takes a data object (`KbzPayPaymentData`, `WaveMoneyPaymentData` with `WaveMoneyItem`s, `AyaPayPaymentData` with an `AyaPayMethod`, `YomaMmqrPaymentData`, `CyberSourcePaymentData` with a `CyberSourceTransactionType`) and returns a typed result:
+Each gateway takes a data object (`KbzPayPaymentData`, `WaveMoneyPaymentData` with `WaveMoneyItem`s, `AyaPayPaymentData` with an `AyaPayMethod`, `YomaMmqrPaymentData`, `CyberSourcePaymentData` with a `CyberSourceTransactionType`) and returns a typed result. `CyberSourcePaymentData` has no defaults: set `currency` (e.g. `"MMK"`), `locale` (e.g. `"en-us"`) and `transaction_type` (e.g. `CyberSourceTransactionType.SALE`).
 
 ```python
 from python_myanmar_payments import Amount, KbzPayPaymentData

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/src/python_myanmar_payments/__init__.py

@@ -15,7 +15,6 @@ from ._errors import (
     SignatureVerificationError,
 )
 from ._facade import AsyncMyanmarPayments, MyanmarPayments
-from ._http import DEFAULT_TIMEOUT
 from ._results import (
     Acknowledgement,
     AppPayment,
@@ -54,7 +53,6 @@ from .wave_money import (
 from .yoma_mmqr import AsyncYomaMmqr, YomaMmqr, YomaMmqrConfig, YomaMmqrPaymentData
 
 __all__ = [
-    "DEFAULT_TIMEOUT",
     "Acknowledgement",
     "Amount",
     "AmountInput",

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/src/python_myanmar_payments/_errors.py

@@ -81,14 +81,22 @@ class SignatureVerificationError(PaymentError):
 
 
 class ConfigurationError(PaymentError):
-    """Raised when a gateway is missing a credential or setting it needs."""
+    """Raised when a gateway is missing a credential or setting it needs.
+
+    ``invalid`` reports a time setting that is set but not a whole number greater
+    than 0.
+    """
 
     gateway: str
     """The gateway, e.g. ``kbz_pay``."""
     key: str
-    """The missing setting, e.g. ``app_key``."""
+    """The missing or invalid setting, e.g. ``app_key``."""
 
-    def __init__(self, gateway: str, key: str) -> None:
-        super().__init__(f"The {gateway} configuration is missing [{key}].")
+    def __init__(self, gateway: str, key: str, invalid: bool = False) -> None:
+        if invalid:
+            message = f"The {gateway} configuration [{key}] must be a whole number greater than 0."
+        else:
+            message = f"The {gateway} configuration is missing [{key}]."
+        super().__init__(message)
         self.gateway = gateway
         self.key = key

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/src/python_myanmar_payments/_facade.py

@@ -10,7 +10,6 @@ import httpx
 
 from ._cache import AsyncTokenCache, MemoryTokenCache, TokenCache
 from ._errors import ConfigurationError
-from ._http import DEFAULT_TIMEOUT
 from ._support import EnvSource, config_of
 from .aya_pay import AsyncAyaPay, AyaPay, AyaPayConfig
 from .cyber_source import CyberSource, CyberSourceConfig
@@ -43,14 +42,12 @@ class _Payments:
         aya_pay: AyaPayConfig | Mapping[str, Any] | None,
         yoma_mmqr: YomaMmqrConfig | Mapping[str, Any] | None,
         cyber_source: CyberSourceConfig | Mapping[str, Any] | None,
-        timeout: float | None,
     ) -> None:
         self._kbz_pay_config = _lazy(KbzPayConfig, kbz_pay)
         self._wave_money_config = _lazy(WaveMoneyConfig, wave_money)
         self._aya_pay_config = _lazy(AyaPayConfig, aya_pay)
         self._yoma_mmqr_config = _lazy(YomaMmqrConfig, yoma_mmqr)
         self._cyber_source_config = _lazy(CyberSourceConfig, cyber_source)
-        self._timeout = timeout
         self._cyber_source: CyberSource | None = None
 
     def _read_env(self, env: EnvSource | None) -> None:
@@ -86,9 +83,8 @@ class MyanmarPayments(_Payments):
         cyber_source: CyberSourceConfig | Mapping[str, Any] | None = None,
         token_cache: TokenCache | None = None,
         http_client: httpx.Client | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> None:
-        super().__init__(kbz_pay, wave_money, aya_pay, yoma_mmqr, cyber_source, timeout)
+        super().__init__(kbz_pay, wave_money, aya_pay, yoma_mmqr, cyber_source)
         self._http_client = http_client
         self._token_cache: TokenCache = (
             token_cache if token_cache is not None else MemoryTokenCache()
@@ -105,15 +101,14 @@ class MyanmarPayments(_Payments):
         *,
         token_cache: TokenCache | None = None,
         http_client: httpx.Client | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> MyanmarPayments:
         """Reads every gateway's configuration from environment variables.
 
-        ``KBZ_PAY_*``, ``WAVE_MONEY_*``, ``AYA_PAY_*``, ``YOMA_MMQR_*`` and
-        ``CYBER_SOURCE_*`` are read when the gateway is first used. Defaults to
-        ``os.environ``.
+        ``KBZ_PAY_*``, ``WAVE_MONEY_*``, ``AYA_PAY_*``, ``YOMA_MMQR_*``,
+        ``CYBER_SOURCE_*`` and ``MYANMAR_PAYMENTS_HTTP_TIMEOUT`` are read when the
+        gateway is first used. Defaults to ``os.environ``.
         """
-        payments = cls(token_cache=token_cache, http_client=http_client, timeout=timeout)
+        payments = cls(token_cache=token_cache, http_client=http_client)
         payments._read_env(env)
         return payments
 
@@ -121,23 +116,21 @@ class MyanmarPayments(_Payments):
         """The KBZ Pay gateway. Raises a ``ConfigurationError`` when not configured."""
         if self._kbz_pay is None:
             config = _resolve(self._kbz_pay_config, "kbz_pay", "app_id")
-            self._kbz_pay = KbzPay(config, http_client=self._http_client, timeout=self._timeout)
+            self._kbz_pay = KbzPay(config, http_client=self._http_client)
         return self._kbz_pay
 
     def wave_money(self) -> WaveMoney:
         """The Wave Money gateway. Raises a ``ConfigurationError`` when not configured."""
         if self._wave_money is None:
             config = _resolve(self._wave_money_config, "wave_money", "merchant_id")
-            self._wave_money = WaveMoney(
-                config, http_client=self._http_client, timeout=self._timeout
-            )
+            self._wave_money = WaveMoney(config, http_client=self._http_client)
         return self._wave_money
 
     def aya_pay(self) -> AyaPay:
         """The AYA Payment Gateway. Raises a ``ConfigurationError`` when not configured."""
         if self._aya_pay is None:
             config = _resolve(self._aya_pay_config, "aya_pay", "app_key")
-            self._aya_pay = AyaPay(config, http_client=self._http_client, timeout=self._timeout)
+            self._aya_pay = AyaPay(config, http_client=self._http_client)
         return self._aya_pay
 
     def yoma_mmqr(self) -> YomaMmqr:
@@ -148,7 +141,6 @@ class MyanmarPayments(_Payments):
                 config,
                 token_cache=self._token_cache,
                 http_client=self._http_client,
-                timeout=self._timeout,
             )
         return self._yoma_mmqr
 
@@ -188,9 +180,8 @@ class AsyncMyanmarPayments(_Payments):
         cyber_source: CyberSourceConfig | Mapping[str, Any] | None = None,
         token_cache: TokenCache | AsyncTokenCache | None = None,
         http_client: httpx.AsyncClient | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> None:
-        super().__init__(kbz_pay, wave_money, aya_pay, yoma_mmqr, cyber_source, timeout)
+        super().__init__(kbz_pay, wave_money, aya_pay, yoma_mmqr, cyber_source)
         self._http_client = http_client
         self._token_cache: TokenCache | AsyncTokenCache = (
             token_cache if token_cache is not None else MemoryTokenCache()
@@ -207,10 +198,9 @@ class AsyncMyanmarPayments(_Payments):
         *,
         token_cache: TokenCache | AsyncTokenCache | None = None,
         http_client: httpx.AsyncClient | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> AsyncMyanmarPayments:
         """Reads every gateway's configuration from environment variables on first use."""
-        payments = cls(token_cache=token_cache, http_client=http_client, timeout=timeout)
+        payments = cls(token_cache=token_cache, http_client=http_client)
         payments._read_env(env)
         return payments
 
@@ -218,27 +208,21 @@ class AsyncMyanmarPayments(_Payments):
         """The KBZ Pay gateway. Raises a ``ConfigurationError`` when not configured."""
         if self._kbz_pay is None:
             config = _resolve(self._kbz_pay_config, "kbz_pay", "app_id")
-            self._kbz_pay = AsyncKbzPay(
-                config, http_client=self._http_client, timeout=self._timeout
-            )
+            self._kbz_pay = AsyncKbzPay(config, http_client=self._http_client)
         return self._kbz_pay
 
     def wave_money(self) -> AsyncWaveMoney:
         """The Wave Money gateway. Raises a ``ConfigurationError`` when not configured."""
         if self._wave_money is None:
             config = _resolve(self._wave_money_config, "wave_money", "merchant_id")
-            self._wave_money = AsyncWaveMoney(
-                config, http_client=self._http_client, timeout=self._timeout
-            )
+            self._wave_money = AsyncWaveMoney(config, http_client=self._http_client)
         return self._wave_money
 
     def aya_pay(self) -> AsyncAyaPay:
         """The AYA Payment Gateway. Raises a ``ConfigurationError`` when not configured."""
         if self._aya_pay is None:
             config = _resolve(self._aya_pay_config, "aya_pay", "app_key")
-            self._aya_pay = AsyncAyaPay(
-                config, http_client=self._http_client, timeout=self._timeout
-            )
+            self._aya_pay = AsyncAyaPay(config, http_client=self._http_client)
         return self._aya_pay
 
     def yoma_mmqr(self) -> AsyncYomaMmqr:
@@ -249,7 +233,6 @@ class AsyncMyanmarPayments(_Payments):
                 config,
                 token_cache=self._token_cache,
                 http_client=self._http_client,
-                timeout=self._timeout,
             )
         return self._yoma_mmqr
 

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/src/python_myanmar_payments/_http.py

@@ -14,9 +14,6 @@ import httpx
 from ._errors import ApiError
 from ._json import LosslessObject, dumps, parse_object
 
-DEFAULT_TIMEOUT = 30.0
-"""The default request timeout, in seconds."""
-
 
 @dataclass(frozen=True)
 class HttpRequest:
@@ -81,7 +78,7 @@ def _response(response: httpx.Response) -> GatewayResponse:
 class SyncTransport:
     """Posts requests with an ``httpx.Client``, created on first use unless given."""
 
-    def __init__(self, client: httpx.Client | None, timeout: float | None) -> None:
+    def __init__(self, client: httpx.Client | None, timeout: float) -> None:
         self._client = client
         self._owns_client = client is None
         self._timeout = timeout
@@ -113,7 +110,7 @@ class SyncTransport:
 class AsyncTransport:
     """Posts requests with an ``httpx.AsyncClient``, created on first use unless given."""
 
-    def __init__(self, client: httpx.AsyncClient | None, timeout: float | None) -> None:
+    def __init__(self, client: httpx.AsyncClient | None, timeout: float) -> None:
         self._client = client
         self._owns_client = client is None
         self._timeout = timeout
@@ -147,13 +144,14 @@ class SyncGateway:
     """A gateway that calls its API with a synchronous ``httpx.Client``.
 
     Pass ``http_client`` to share a client (proxies, tracing, test transports);
-    otherwise one is created on first use with ``timeout`` seconds (default 30)
-    and closed by :meth:`close` or a ``with`` block.
+    otherwise one is created on first use with the config's ``timeout_seconds``
+    and closed by :meth:`close` or a ``with`` block. A client you pass keeps its
+    own timeout.
     """
 
     _transport: SyncTransport
 
-    def _init_transport(self, http_client: httpx.Client | None, timeout: float | None) -> None:
+    def _init_transport(self, http_client: httpx.Client | None, timeout: float) -> None:
         self._transport = SyncTransport(http_client, timeout)
 
     def close(self) -> None:
@@ -176,13 +174,13 @@ class AsyncGateway:
     """A gateway that calls its API with an ``httpx.AsyncClient``.
 
     Pass ``http_client`` to share a client; otherwise one is created on first use
-    with ``timeout`` seconds (default 30) and closed by :meth:`aclose` or an
-    ``async with`` block.
+    with the config's ``timeout_seconds`` and closed by :meth:`aclose` or an
+    ``async with`` block. A client you pass keeps its own timeout.
     """
 
     _transport: AsyncTransport
 
-    def _init_transport(self, http_client: httpx.AsyncClient | None, timeout: float | None) -> None:
+    def _init_transport(self, http_client: httpx.AsyncClient | None, timeout: float) -> None:
         self._transport = AsyncTransport(http_client, timeout)
 
     async def aclose(self) -> None:

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/src/python_myanmar_payments/_support.py

@@ -117,25 +117,6 @@ def env_first(env: EnvSource, *keys: str) -> str:
     return ""
 
 
-_FALSE = frozenset({"false", "0", "f", "no", "off"})
-
-
-def env_sandbox(env: EnvSource, key: str) -> bool:
-    """Reads a ``*_SANDBOX`` variable.
-
-    Only ``false``, ``0``, ``f``, ``no`` and ``off`` (any case) select production;
-    unset or unrecognized values mean sandbox.
-    """
-    return sandbox_flag(env.get(key) or "")
-
-
-def sandbox_flag(value: bool | str) -> bool:
-    """A ``sandbox`` setting: a bool, or text read like a ``*_SANDBOX`` variable."""
-    if isinstance(value, str):
-        return value.strip().lower() not in _FALSE
-    return bool(value)
-
-
 _C = TypeVar("_C")
 
 
@@ -149,10 +130,22 @@ def config_of(config_class: type[_C], config: _C | Mapping[str, Any]) -> _C:
 _INT = re.compile(r"[+-]?[0-9]+")
 
 
-def env_int(env: EnvSource, key: str) -> int | None:
-    """An integer variable, or ``None`` when unset or not an integer."""
-    value = (env.get(key) or "").strip()
-    return int(value) if _INT.fullmatch(value) else None
+def require_seconds(gateway: str, key: str, value: object) -> int:
+    """A whole number of seconds greater than 0, given as an int or integer text.
+
+    Unset or blank raises a :class:`ConfigurationError` naming ``key``; anything
+    else that is not a whole number greater than 0 raises it as invalid.
+    """
+    if value is None or (isinstance(value, str) and value.strip() == ""):
+        raise ConfigurationError(gateway, key)
+    seconds: int | None = None
+    if isinstance(value, int) and not isinstance(value, bool):
+        seconds = value
+    elif isinstance(value, str) and _INT.fullmatch(value.strip()):
+        seconds = int(value.strip())
+    if seconds is None or seconds <= 0:
+        raise ConfigurationError(gateway, key, invalid=True)
+    return seconds
 
 
 def require_setting(gateway: str, key: str, value: object) -> str:

python_myanmar_payments-4.0.0a2/src/python_myanmar_payments/_version.py

@@ -0,0 +1 @@
+__version__ = "4.0.0a2"

{python_myanmar_payments-4.0.0a1 → python_myanmar_payments-4.0.0a2}/src/python_myanmar_payments/aya_pay.py

@@ -12,7 +12,6 @@ from ._amount import AmountInput, to_amount
 from ._callback import CallbackRequest, lossless_input, lossless_query_input
 from ._errors import ApiError, SignatureVerificationError
 from ._http import (
-    DEFAULT_TIMEOUT,
     AsyncGateway,
     GatewayResponse,
     HttpRequest,
@@ -28,12 +27,11 @@ from ._support import (
     decode_base64,
     default_env,
     env_first,
-    env_sandbox,
     hmac_sha256_hex,
     optional_setting,
+    require_seconds,
     require_setting,
     safe_equal,
-    sandbox_flag,
     trim_url,
     unix_time,
 )
@@ -53,18 +51,19 @@ __all__ = [
 class AyaPayConfig:
     """AYA Payment Gateway (APG) credentials and endpoints.
 
-    A missing credential raises a :class:`~python_myanmar_payments.ConfigurationError`.
+    Every setting except the URL override is required; a missing one raises a
+    :class:`~python_myanmar_payments.ConfigurationError`. The URL defaults to
+    production.
     """
 
-    SANDBOX_URL: ClassVar[str] = "https://uat-pgw.ayainnovation.com"
     PRODUCTION_URL: ClassVar[str] = "https://pgw.ayainnovation.com"
 
     app_key: str
     """The public application key, sent with every request."""
     app_secret: str
     """The secret that signs requests and verifies callbacks."""
-    sandbox: bool
-    """Whether the UAT environment is used."""
+    timeout_seconds: int
+    """Seconds before the default HTTP client gives up on a request."""
     base_url: str
     """The base URL in use."""
 
@@ -73,34 +72,32 @@ class AyaPayConfig:
         *,
         app_key: str = "",
         app_secret: str = "",
-        sandbox: bool | str = True,
+        timeout_seconds: int | str | None = None,
         base_url: str | None = None,
     ) -> None:
         self.app_key = require_setting("aya_pay", "app_key", app_key)
         self.app_secret = require_setting("aya_pay", "app_secret", app_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.timeout_seconds = require_seconds("aya_pay", "timeout_in_seconds", timeout_seconds)
+        self.base_url = trim_url(optional_setting(base_url) or self.PRODUCTION_URL)
 
     @classmethod
     def from_env(cls, env: EnvSource | None = None) -> AyaPayConfig:
         """Reads the ``AYA_PAY_*`` environment variables.
 
-        ``AYA_PAY_APP_KEY``, ``AYA_PAY_APP_SECRET``, ``AYA_PAY_SANDBOX`` and
-        ``AYA_PAY_BASE_URL``, falling back to the ``AYA_PGW_*`` names. Defaults to
-        ``os.environ``.
+        ``AYA_PAY_APP_KEY``, ``AYA_PAY_APP_SECRET``, ``MYANMAR_PAYMENTS_HTTP_TIMEOUT``
+        and ``AYA_PAY_BASE_URL``, falling back to the ``AYA_PGW_*`` names. Defaults
+        to ``os.environ``.
         """
         env = default_env() if env is None else env
         return cls(
             app_key=env_first(env, "AYA_PAY_APP_KEY", "AYA_PGW_APP_KEY"),
             app_secret=env_first(env, "AYA_PAY_APP_SECRET", "AYA_PGW_APP_SECRET"),
-            sandbox=env_sandbox(env, "AYA_PAY_SANDBOX"),
+            timeout_seconds=env_first(env, "MYANMAR_PAYMENTS_HTTP_TIMEOUT"),
             base_url=env_first(env, "AYA_PAY_BASE_URL", "AYA_PGW_BASE_URL"),
         )
 
     def __repr__(self) -> str:
-        return f"AyaPayConfig(app_key={self.app_key!r}, sandbox={self.sandbox!r})"
+        return f"AyaPayConfig(app_key={self.app_key!r})"
 
 
 class AyaPayMethod(_StrEnum):
@@ -444,10 +441,9 @@ class AyaPay(_AyaPayBase, SyncGateway):
         config: AyaPayConfig | Mapping[str, Any],
         *,
         http_client: httpx.Client | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> None:
         super().__init__(config)
-        self._init_transport(http_client, timeout)
+        self._init_transport(http_client, self.config.timeout_seconds)
 
     @classmethod
     def from_env(
@@ -455,10 +451,9 @@ class AyaPay(_AyaPayBase, SyncGateway):
         env: EnvSource | None = None,
         *,
         http_client: httpx.Client | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> AyaPay:
         """A gateway configured from the ``AYA_PAY_*`` (or ``AYA_PGW_*``) variables."""
-        return cls(AyaPayConfig.from_env(env), http_client=http_client, timeout=timeout)
+        return cls(AyaPayConfig.from_env(env), http_client=http_client)
 
     def services(self) -> list[AyaPayService]:
         """Lists the payment channels enabled for your merchant account."""
@@ -482,10 +477,9 @@ class AsyncAyaPay(_AyaPayBase, AsyncGateway):
         config: AyaPayConfig | Mapping[str, Any],
         *,
         http_client: httpx.AsyncClient | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> None:
         super().__init__(config)
-        self._init_transport(http_client, timeout)
+        self._init_transport(http_client, self.config.timeout_seconds)
 
     @classmethod
     def from_env(
@@ -493,10 +487,9 @@ class AsyncAyaPay(_AyaPayBase, AsyncGateway):
         env: EnvSource | None = None,
         *,
         http_client: httpx.AsyncClient | None = None,
-        timeout: float | None = DEFAULT_TIMEOUT,
     ) -> AsyncAyaPay:
         """A gateway configured from the ``AYA_PAY_*`` (or ``AYA_PGW_*``) variables."""
-        return cls(AyaPayConfig.from_env(env), http_client=http_client, timeout=timeout)
+        return cls(AyaPayConfig.from_env(env), http_client=http_client)
 
     async def services(self) -> list[AyaPayService]:
         """Lists the payment channels enabled for your merchant account."""