bazik-sdk 0.1.0__tar.gz

bazik_sdk-0.1.0/.gitignore

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

bazik_sdk-0.1.0/LICENSE

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

bazik_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: bazik-sdk
+Version: 0.1.0
+Summary: Async Python SDK for the Bazik API — MonCash payments for Haiti.
+Project-URL: Homepage, https://github.com/FalandyJEAN/bazik-sdk-python
+Project-URL: Issues, https://github.com/FalandyJEAN/bazik-sdk-python/issues
+Author: Falandy Jean
+License: MIT
+License-File: LICENSE
+Keywords: bazik,haiti,moncash,natcash,payments
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Description-Content-Type: text/markdown
+
+# bazik-sdk (Python)
+
+Tiny **async** Python client for the [Bazik](https://bazik.io) API — **MonCash** payments for Haiti. Production-tested (powers payments on TradeMakaya). One dependency: `httpx`.
+
+## Install
+
+```bash
+pip install bazik-sdk
+```
+
+## Quick start
+
+```python
+import asyncio
+from bazik import BazikClient
+
+async def main():
+    client = BazikClient(user_id="YOUR_USER_ID", secret_key="YOUR_SECRET_KEY")
+
+    # 1) Create a payment (amount in gourdes, max 75,000 HTG)
+    order = await client.create_moncash_payment(
+        gdes=500,
+        reference_id="INV-1001",
+        description="Pro plan",
+        customer_first_name="Jean",
+        customer_last_name="Pierre",
+        customer_email="jean@example.com",
+        webhook_url="https://api.yoursite.com/billing/moncash/webhook",
+        success_url="https://yoursite.com/paid",
+        error_url="https://yoursite.com/canceled",
+    )
+    print("Send the customer to:", order["redirectUrl"])
+
+    # 2) Check status (or poll until it resolves)
+    result = await client.wait_for_completion(order["orderId"], interval=3, timeout=180)
+    print("Status:", result["status"])   # "successful" | "pending" | "failed"
+
+asyncio.run(main())
+```
+
+## API
+
+| Method | Description |
+|---|---|
+| `BazikClient(user_id, secret_key, base_url=…, timeout=20)` | Create a client. |
+| `await authenticate()` | Fetch & cache a bearer token (auto-called). |
+| `await create_moncash_payment(*, gdes, reference_id, …)` | Create a MonCash payment → `{orderId, redirectUrl, …}`. |
+| `await verify_payment(order_id)` | Current status → `{status, referenceId, …}`. |
+| `await wait_for_completion(order_id, *, interval=3, timeout=180)` | Poll until resolved. |
+
+`create_moncash_payment` optional fields: `webhook_url`, `description`, `customer_first_name`, `customer_last_name`, `customer_email`, `success_url`, `error_url`.
+
+Errors raise `bazik.BazikError` (`.status_code`, `.body`).
+
+> **Note:** the amount field is `gdes` (gourdes) — not `gourdes`. Sending the wrong key creates a payment with no amount.
+
+## Webhook flow
+
+Bazik POSTs `{ orderId }` to your `webhook_url` on a status change. **Don't trust the body** — verify:
+
+```python
+verified = await client.verify_payment(order_id)
+if verified["status"] == "successful":
+    ...  # activate the order
+```
+
+## License
+
+MIT © Falandy Jean. Unofficial SDK; not affiliated with Bazik.

bazik_sdk-0.1.0/README.md

@@ -0,0 +1,69 @@
+# bazik-sdk (Python)
+
+Tiny **async** Python client for the [Bazik](https://bazik.io) API — **MonCash** payments for Haiti. Production-tested (powers payments on TradeMakaya). One dependency: `httpx`.
+
+## Install
+
+```bash
+pip install bazik-sdk
+```
+
+## Quick start
+
+```python
+import asyncio
+from bazik import BazikClient
+
+async def main():
+    client = BazikClient(user_id="YOUR_USER_ID", secret_key="YOUR_SECRET_KEY")
+
+    # 1) Create a payment (amount in gourdes, max 75,000 HTG)
+    order = await client.create_moncash_payment(
+        gdes=500,
+        reference_id="INV-1001",
+        description="Pro plan",
+        customer_first_name="Jean",
+        customer_last_name="Pierre",
+        customer_email="jean@example.com",
+        webhook_url="https://api.yoursite.com/billing/moncash/webhook",
+        success_url="https://yoursite.com/paid",
+        error_url="https://yoursite.com/canceled",
+    )
+    print("Send the customer to:", order["redirectUrl"])
+
+    # 2) Check status (or poll until it resolves)
+    result = await client.wait_for_completion(order["orderId"], interval=3, timeout=180)
+    print("Status:", result["status"])   # "successful" | "pending" | "failed"
+
+asyncio.run(main())
+```
+
+## API
+
+| Method | Description |
+|---|---|
+| `BazikClient(user_id, secret_key, base_url=…, timeout=20)` | Create a client. |
+| `await authenticate()` | Fetch & cache a bearer token (auto-called). |
+| `await create_moncash_payment(*, gdes, reference_id, …)` | Create a MonCash payment → `{orderId, redirectUrl, …}`. |
+| `await verify_payment(order_id)` | Current status → `{status, referenceId, …}`. |
+| `await wait_for_completion(order_id, *, interval=3, timeout=180)` | Poll until resolved. |
+
+`create_moncash_payment` optional fields: `webhook_url`, `description`, `customer_first_name`, `customer_last_name`, `customer_email`, `success_url`, `error_url`.
+
+Errors raise `bazik.BazikError` (`.status_code`, `.body`).
+
+> **Note:** the amount field is `gdes` (gourdes) — not `gourdes`. Sending the wrong key creates a payment with no amount.
+
+## Webhook flow
+
+Bazik POSTs `{ orderId }` to your `webhook_url` on a status change. **Don't trust the body** — verify:
+
+```python
+verified = await client.verify_payment(order_id)
+if verified["status"] == "successful":
+    ...  # activate the order
+```
+
+## License
+
+MIT © Falandy Jean. Unofficial SDK; not affiliated with Bazik.

bazik_sdk-0.1.0/bazik/__init__.py

@@ -0,0 +1,6 @@
+"""bazik — a tiny async Python client for the Bazik API (MonCash payments, Haiti)."""
+from .client import BazikClient, DEFAULT_BASE_URL
+from .errors import BazikError
+
+__all__ = ["BazikClient", "BazikError", "DEFAULT_BASE_URL"]
+__version__ = "0.1.0"

bazik_sdk-0.1.0/bazik/client.py

@@ -0,0 +1,120 @@
+"""Async Bazik client for MonCash payments in Haiti.
+
+Battle-tested in production (TradeMakaya). Mirrors the official Bazik API over HTTP:
+
+    POST /token            {userID, secretKey}            -> { token, expires_at }
+    POST /moncash/token    (Bearer) {gdes, referenceId…}  -> { orderId, redirectUrl, status }
+    GET  /order/{orderId}  (Bearer)                        -> { status, referenceId, … }
+
+The amount field is **gdes** (gourdes), NOT "gourdes" — sending the wrong key makes Bazik
+create a payment without an amount.
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Optional
+
+import httpx
+
+from .errors import BazikError
+
+DEFAULT_BASE_URL = "https://api.bazik.io"
+
+
+class BazikClient:
+    """A minimal, dependency-light (httpx only) async client for the Bazik API.
+
+    Example
+    -------
+    >>> client = BazikClient(user_id="...", secret_key="...")
+    >>> order = await client.create_moncash_payment(gdes=500, reference_id="INV-1",
+    ...                                              webhook_url="https://api.me/webhook")
+    >>> print(order["redirectUrl"])             # send the customer here to pay
+    >>> result = await client.wait_for_completion(order["orderId"])
+    >>> assert result["status"] == "successful"
+    """
+
+    def __init__(self, user_id: str, secret_key: str, base_url: str = DEFAULT_BASE_URL,
+                 timeout: float = 20.0):
+        if not user_id or not secret_key:
+            raise ValueError("BazikClient requires user_id and secret_key.")
+        self.user_id = user_id
+        self.secret_key = secret_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._token: Optional[str] = None
+        self._token_exp: float = 0.0
+
+    # ---- auth -----------------------------------------------------------------
+    async def authenticate(self) -> str:
+        """Fetch (and cache) a bearer token. Called automatically by other methods."""
+        now = time.time()
+        if self._token and now < self._token_exp - 60:
+            return self._token
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            r = await client.post(f"{self.base_url}/token",
+                                  json={"userID": self.user_id, "secretKey": self.secret_key})
+        if r.status_code >= 400:
+            raise BazikError(f"/token failed ({r.status_code})", r.status_code, r.text[:300])
+        try:
+            data = r.json()
+        except Exception:
+            raise BazikError("/token: non-JSON response", r.status_code, r.text[:300])
+        token = data.get("token") or data.get("access_token") or (data.get("data") or {}).get("token")
+        if not token:
+            raise BazikError(f"/token: no token in response: {str(data)[:200]}")
+        self._token = token
+        exp_at = data.get("expires_at")
+        self._token_exp = (exp_at / 1000) if isinstance(exp_at, (int, float)) else now + 86400
+        return token
+
+    async def _headers(self) -> dict:
+        return {"Authorization": f"Bearer {await self.authenticate()}",
+                "Content-Type": "application/json"}
+
+    # ---- payments -------------------------------------------------------------
+    async def create_moncash_payment(self, *, gdes: int, reference_id: str,
+                                     webhook_url: Optional[str] = None,
+                                     description: Optional[str] = None,
+                                     customer_first_name: Optional[str] = None,
+                                     customer_last_name: Optional[str] = None,
+                                     customer_email: Optional[str] = None,
+                                     success_url: Optional[str] = None,
+                                     error_url: Optional[str] = None) -> dict[str, Any]:
+        """Create a MonCash payment (max 75,000 HTG). Returns Bazik's raw response,
+        including ``orderId`` and ``redirectUrl`` (where you send the customer to pay)."""
+        payload: dict[str, Any] = {"gdes": gdes, "referenceId": reference_id}
+        for k, v in (("description", description), ("customerFirstName", customer_first_name),
+                     ("customerLastName", customer_last_name), ("customerEmail", customer_email),
+                     ("webhookUrl", webhook_url), ("successUrl", success_url), ("errorUrl", error_url)):
+            if v:
+                payload[k] = v
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            r = await client.post(f"{self.base_url}/moncash/token", json=payload,
+                                  headers=await self._headers())
+        if r.status_code >= 400:
+            raise BazikError(f"/moncash/token failed ({r.status_code})", r.status_code, r.text[:300])
+        return r.json()
+
+    async def verify_payment(self, order_id: str) -> dict[str, Any]:
+        """Fetch a payment's current status. ``status == 'successful'`` once paid
+        (other values: ``'pending'``, ``'failed'``)."""
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            r = await client.get(f"{self.base_url}/order/{order_id}", headers=await self._headers())
+        if r.status_code >= 400:
+            raise BazikError(f"/order failed ({r.status_code})", r.status_code, r.text[:300])
+        return r.json()
+
+    async def wait_for_completion(self, order_id: str, *, interval: float = 3.0,
+                                  timeout: float = 180.0) -> dict[str, Any]:
+        """Poll ``verify_payment`` until the order resolves (successful/failed) or the
+        timeout elapses. Returns the last status payload."""
+        deadline = time.time() + timeout
+        last: dict[str, Any] = {}
+        while time.time() < deadline:
+            last = await self.verify_payment(order_id)
+            if (last.get("status") or "").lower() in ("successful", "failed", "canceled", "cancelled"):
+                return last
+            await asyncio.sleep(interval)
+        return last

bazik_sdk-0.1.0/bazik/errors.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+class BazikError(RuntimeError):
+    """Raised when the Bazik API returns an error or an unexpected response."""
+
+    def __init__(self, message: str, status_code: int | None = None, body: str | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body

bazik_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bazik-sdk"
+version = "0.1.0"
+description = "Async Python SDK for the Bazik API — MonCash payments for Haiti."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Falandy Jean" }]
+keywords = ["bazik", "moncash", "haiti", "payments", "natcash"]
+dependencies = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://github.com/FalandyJEAN/bazik-sdk-python"
+Issues = "https://github.com/FalandyJEAN/bazik-sdk-python/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["bazik"]