hostpay 0.1.0__py3-none-any.whl

hostpay/__init__.py

@@ -0,0 +1,31 @@
+"""HostPay Python SDK."""
+from ._client import HostPay
+from ._object import HostPayObject
+from .errors import (
+    APIConnectionError,
+    APIError,
+    AuthenticationError,
+    HostPayError,
+    InvalidRequestError,
+    RateLimitError,
+    SignatureVerificationError,
+)
+from .models import EscrowResponse, TransactionResponse, UserRead, WalletRead
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "HostPay",
+    "HostPayObject",
+    "HostPayError",
+    "AuthenticationError",
+    "InvalidRequestError",
+    "RateLimitError",
+    "APIError",
+    "APIConnectionError",
+    "SignatureVerificationError",
+    "UserRead",
+    "WalletRead",
+    "TransactionResponse",
+    "EscrowResponse",
+]

hostpay/_client.py

@@ -0,0 +1,129 @@
+"""HTTP transport + the top-level HostPay client."""
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ._object import HostPayObject, _wrap
+from .errors import APIConnectionError, error_from_status
+from .resources import Deposits, Escrow, Payouts, Transfers, Users, Wallets
+from .webhooks import Webhooks
+
+DEFAULT_BASE_URL = "https://hpay-api.host-sl.com"
+
+
+class _Transport:
+    """Builds authenticated requests, retries transient failures, maps errors."""
+
+    def __init__(
+        self,
+        api_key: str,
+        secret_key: str,
+        base_url: str,
+        timeout: float,
+        max_retries: int,
+        http_client: Optional[httpx.Client],
+    ) -> None:
+        self._max_retries = max_retries
+        # Auth is applied per-request so a caller-supplied http_client is still
+        # authenticated.
+        self._auth = {
+            "api-key": api_key,
+            "secret-key": secret_key,
+            "User-Agent": "hostpay-python/0.1.0",
+        }
+        self._client = http_client or httpx.Client(
+            base_url=base_url.rstrip("/"), timeout=timeout
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[dict] = None,
+        params: Optional[dict] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        headers: Dict[str, str] = dict(self._auth)
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        # Retry only idempotent-safe conditions: connection errors and 5xx. POSTs
+        # are retried too — the API supports Idempotency-Key for money movements.
+        last_exc: Optional[Exception] = None
+        for attempt in range(self._max_retries + 1):
+            try:
+                resp = self._client.request(
+                    method, path, json=json, params=params, headers=headers
+                )
+            except httpx.HTTPError as exc:
+                last_exc = exc
+                if attempt < self._max_retries:
+                    time.sleep(0.5 * (2 ** attempt))
+                    continue
+                raise APIConnectionError(f"Could not reach HostPay: {exc}") from exc
+
+            if resp.status_code >= 500 and attempt < self._max_retries:
+                time.sleep(0.5 * (2 ** attempt))
+                continue
+            return _handle_response(resp)
+        raise APIConnectionError(f"Could not reach HostPay: {last_exc}")
+
+    def close(self) -> None:
+        self._client.close()
+
+
+def _handle_response(resp: "httpx.Response") -> Any:
+    if 200 <= resp.status_code < 300:
+        if not resp.content:
+            return None
+        return _wrap(resp.json())
+    try:
+        body = resp.json()
+        detail = body.get("detail", body) if isinstance(body, dict) else body
+    except ValueError:
+        detail = resp.text
+    message = detail if isinstance(detail, str) else f"HTTP {resp.status_code}"
+    raise error_from_status(resp.status_code, message, detail)
+
+
+class HostPay:
+    """HostPay API client.
+
+    >>> client = HostPay(api_key="ak-...", secret_key="sk-...")
+    >>> user = client.users.create(app_user_id="u1", name="Alice", phone_number="+23279000000")
+    >>> wallet = client.wallets.create(user.id)
+    >>> client.deposits.mobile_money(wallet_id=wallet.id, amount=100)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        secret_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        if not api_key or not secret_key:
+            raise ValueError("api_key and secret_key are required")
+        self._transport = _Transport(
+            api_key, secret_key, base_url, timeout, max_retries, http_client
+        )
+        self.users = Users(self._transport)
+        self.wallets = Wallets(self._transport)
+        self.deposits = Deposits(self._transport)
+        self.transfers = Transfers(self._transport)
+        self.payouts = Payouts(self._transport)
+        self.escrow = Escrow(self._transport)
+        self.webhooks = Webhooks()
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> "HostPay":
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()

hostpay/_object.py

@@ -0,0 +1,31 @@
+"""Lightweight attribute-access wrapper for API responses.
+
+Responses come back as HostPayObject so you can use `wallet.id` and
+`wallet["id"]` interchangeably. Unknown/new fields are preserved automatically —
+strict typed models can be generated later from ../openapi.json.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+class HostPayObject(dict):
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return _wrap(self[name])
+        except KeyError as exc:
+            raise AttributeError(name) from exc
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        self[name] = value
+
+    def __repr__(self) -> str:
+        return f"HostPayObject({dict.__repr__(self)})"
+
+
+def _wrap(value: Any) -> Any:
+    if isinstance(value, dict):
+        return HostPayObject(value)
+    if isinstance(value, list):
+        return [_wrap(v) for v in value]
+    return value

hostpay/errors.py

@@ -0,0 +1,54 @@
+"""Exception hierarchy for the HostPay SDK."""
+from __future__ import annotations
+
+from typing import Optional
+
+
+class HostPayError(Exception):
+    """Base class for all SDK errors."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        detail: Optional[object] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.detail = detail
+
+
+class AuthenticationError(HostPayError):
+    """Invalid or missing api-key / secret-key (401, 403)."""
+
+
+class InvalidRequestError(HostPayError):
+    """Bad request, not found, or validation error (400, 404, 422)."""
+
+
+class RateLimitError(HostPayError):
+    """Too many requests (429)."""
+
+
+class APIError(HostPayError):
+    """Server-side error (5xx)."""
+
+
+class APIConnectionError(HostPayError):
+    """Network problem reaching the API."""
+
+
+class SignatureVerificationError(HostPayError):
+    """A webhook signature could not be verified."""
+
+
+def error_from_status(status_code: int, message: str, detail: object) -> HostPayError:
+    if status_code in (401, 403):
+        cls = AuthenticationError
+    elif status_code == 429:
+        cls = RateLimitError
+    elif 400 <= status_code < 500:
+        cls = InvalidRequestError
+    else:
+        cls = APIError
+    return cls(message, status_code=status_code, detail=detail)

hostpay/models.py

@@ -0,0 +1,91 @@
+"""Response models (TypedDict) mirroring the OpenAPI schemas.
+
+Compile-time only: responses are returned as dict-like ``HostPayObject`` at
+runtime, which is structurally these types. Access typed fields with
+``resp["field"]`` (attribute access ``resp.field`` also works at runtime).
+
+Fields mirror ../../openapi.json — the source of truth. Regenerate/refresh when
+the API changes.
+"""
+from __future__ import annotations
+
+from typing import Optional, TypedDict
+
+
+class _UserRequired(TypedDict):
+    id: str
+    app_user_id: str
+    name: str
+    phone_number: str
+    created_at: str
+
+
+class UserRead(_UserRequired, total=False):
+    email: Optional[str]
+    username: Optional[str]
+    is_active: bool
+    stripe_connect_account_id: Optional[str]
+    stripe_connect_verified: Optional[bool]
+
+
+class _WalletRequired(TypedDict):
+    id: str
+    user_id: str
+    balance: str
+    currency: str
+    created_at: str
+    updated_at: str
+
+
+class WalletRead(_WalletRequired, total=False):
+    is_active: bool
+
+
+class _TransactionRequired(TypedDict):
+    id: str
+    amount: str
+    transaction_type: str
+    payment_method: str
+    status: str
+    live_mode: bool
+    timestamp: str
+    created_at: str
+    updated_at: str
+
+
+class TransactionResponse(_TransactionRequired, total=False):
+    currency: Optional[str]
+    description: Optional[str]
+    reference_id: Optional[str]
+    wallet_id: Optional[str]
+    recipient_wallet_id: Optional[str]
+    amount_in_base_currency: Optional[str]
+    application_fee: Optional[str]
+    platform_fee: Optional[str]
+    monime_fee: Optional[str]
+    stripe_fee: Optional[str]
+    estimated_monime_fee: Optional[str]
+    estimated_stripe_fee: Optional[str]
+    total_amount_paid: Optional[str]
+    escrow_amount: Optional[str]
+    escrow_wallet_id: Optional[str]
+    order_id: Optional[str]
+
+
+class _EscrowRequired(TypedDict):
+    id: str
+    wallet_id: str
+    escrow_wallet_id: str
+    amount: float
+    escrow_amount: float
+    status: str
+    transaction_type: str
+    created_at: str
+    updated_at: str
+
+
+class EscrowResponse(_EscrowRequired, total=False):
+    recipient_wallet_id: Optional[str]
+    application_wallet_id: Optional[str]
+    application_fee: Optional[float]
+    description: Optional[str]

hostpay/resources.py

@@ -0,0 +1,171 @@
+"""Resource groups mapped to the HostPay money surface.
+
+Each method mirrors a real endpoint; see ../openapi.json for the full API.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .models import EscrowResponse, TransactionResponse, UserRead, WalletRead
+
+# Mobile-money providers (wire values expected by the API).
+PROVIDER_ORANGE = "m17"
+PROVIDER_AFRICELL = "m18"
+
+
+class _Resource:
+    def __init__(self, transport: Any) -> None:
+        self._t = transport
+
+
+class Users(_Resource):
+    def create(
+        self,
+        app_user_id: str,
+        name: str,
+        phone_number: str,
+        email: Optional[str] = None,
+        username: Optional[str] = None,
+    ) -> UserRead:
+        return self._t.request("POST", "/api/v1/users/create/", json={
+            "app_user_id": app_user_id,
+            "name": name,
+            "phone_number": phone_number,
+            "email": email,
+            "username": username,
+        })
+
+    def get(self, user_id: str) -> UserRead:
+        return self._t.request("GET", f"/api/v1/users/{user_id}/")
+
+
+class Wallets(_Resource):
+    def create(self, user_id: str) -> WalletRead:
+        return self._t.request("POST", f"/api/v1/wallets/create/{user_id}/")
+
+    def get(self, user_id: str) -> WalletRead:
+        return self._t.request("GET", f"/api/v1/wallets/{user_id}/")
+
+    def balance(self, wallet_id: str) -> Any:
+        return self._t.request("GET", f"/api/v1/wallets/{wallet_id}/balance")
+
+
+class Deposits(_Resource):
+    def mobile_money(
+        self, wallet_id: str, amount: int, idempotency_key: Optional[str] = None
+    ) -> Any:
+        return self._t.request(
+            "POST",
+            "/api/v1/transactions/wallet/mobile-money-deposit",
+            json={"wallet_id": wallet_id, "amount": amount},
+            idempotency_key=idempotency_key,
+        )
+
+    def card(
+        self,
+        wallet_id: str,
+        amount: float,
+        payment_method_id: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        return self._t.request(
+            "POST",
+            "/api/v1/transactions/wallet/card-deposit/create",
+            json={
+                "wallet_id": wallet_id,
+                "amount": amount,
+                "payment_method_id": payment_method_id,
+            },
+            idempotency_key=idempotency_key,
+        )
+
+
+class Transfers(_Resource):
+    def create(
+        self,
+        sender_wallet_id: str,
+        recipient_identifier: str,
+        amount: float,
+        description: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> TransactionResponse:
+        return self._t.request(
+            "POST",
+            "/api/v1/transactions/wallet/transfer/",
+            json={
+                "sender_wallet_id": sender_wallet_id,
+                "recipient_identifier": recipient_identifier,
+                "amount": amount,
+                "description": description,
+            },
+            idempotency_key=idempotency_key,
+        )
+
+
+class Payouts(_Resource):
+    def mobile_money(
+        self,
+        wallet_id: str,
+        amount: float,
+        phone_number: str,
+        provider: str = PROVIDER_ORANGE,
+        currency: str = "SLE",
+        idempotency_key: Optional[str] = None,
+    ) -> TransactionResponse:
+        return self._t.request(
+            "POST",
+            "/api/v1/transactions/wallet/mobile-money-cashout/",
+            json={
+                "wallet_id": wallet_id,
+                "amount": amount,
+                "phone_number": phone_number,
+                "provider": provider,
+                "currency": currency,
+            },
+            idempotency_key=idempotency_key,
+        )
+
+    def bank(
+        self,
+        wallet_id: str,
+        amount: float,
+        currency: str = "usd",
+        description: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> TransactionResponse:
+        return self._t.request(
+            "POST",
+            "/api/v1/transactions/wallet/payout/",
+            json={
+                "wallet_id": wallet_id,
+                "amount": amount,
+                "currency": currency,
+                "description": description,
+            },
+            idempotency_key=idempotency_key,
+        )
+
+
+class Escrow(_Resource):
+    def hold(
+        self, wallet_id: str, amount: float, description: Optional[str] = None
+    ) -> EscrowResponse:
+        return self._t.request("POST", "/api/v1/escrow/hold", json={
+            "wallet_id": wallet_id,
+            "amount": amount,
+            "description": description,
+        })
+
+    def release(
+        self, transaction_id: str, recipient_wallet_id: str, amount: Optional[float] = None
+    ) -> EscrowResponse:
+        return self._t.request(
+            "POST",
+            f"/api/v1/escrow/{transaction_id}/release",
+            json={"recipient_wallet_id": recipient_wallet_id, "amount": amount},
+        )
+
+    def refund(self, transaction_id: str, amount: Optional[float] = None) -> EscrowResponse:
+        return self._t.request(
+            "POST", f"/api/v1/escrow/{transaction_id}/refund", json={"amount": amount}
+        )

hostpay/webhooks.py

@@ -0,0 +1,68 @@
+"""Verify inbound HostPay webhooks.
+
+HostPay signs each delivery with:
+    X-Webhook-Timestamp: <unix seconds>
+    X-HostPay-Signature: v1=<hex HMAC-SHA256( secret, "<timestamp>.<raw body>" )>
+
+Pass the **raw** request body (bytes or str) exactly as received — not a
+re-serialized dict — or the signature will not match.
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Mapping, Union
+
+from ._object import HostPayObject
+from .errors import SignatureVerificationError
+
+_SIG_HEADER = "x-hostpay-signature"
+_TS_HEADER = "x-webhook-timestamp"
+
+
+class Webhooks:
+    @staticmethod
+    def construct_event(
+        payload: Union[str, bytes],
+        headers: Mapping[str, str],
+        secret: str,
+        tolerance: int = 300,
+    ) -> Any:
+        """Verify the signature and return the parsed event.
+
+        Raises SignatureVerificationError on any mismatch or if the timestamp is
+        older than `tolerance` seconds (replay protection; set 0 to disable).
+        """
+        body = payload.decode("utf-8") if isinstance(payload, bytes) else payload
+        lower = {k.lower(): v for k, v in headers.items()}
+
+        timestamp = lower.get(_TS_HEADER)
+        sig_header = lower.get(_SIG_HEADER)
+        if not timestamp or not sig_header:
+            raise SignatureVerificationError(
+                "Missing X-Webhook-Timestamp or X-HostPay-Signature header"
+            )
+
+        signature = sig_header[3:] if sig_header.startswith("v1=") else sig_header
+
+        expected = hmac.new(
+            secret.encode("utf-8"),
+            f"{timestamp}.{body}".encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+        if not hmac.compare_digest(expected, signature):
+            raise SignatureVerificationError("Signature mismatch")
+
+        if tolerance:
+            try:
+                age = abs(time.time() - int(timestamp))
+            except ValueError as exc:
+                raise SignatureVerificationError("Invalid timestamp") from exc
+            if age > tolerance:
+                raise SignatureVerificationError(
+                    f"Timestamp outside tolerance ({age:.0f}s > {tolerance}s)"
+                )
+
+        return HostPayObject(json.loads(body))

hostpay-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: hostpay
+Version: 0.1.0
+Summary: Python SDK for the HostPay payments API
+Project-URL: Homepage, https://hpay.host-sl.com
+Project-URL: Documentation, https://hpay.host-sl.com/docs
+Project-URL: Repository, https://github.com/HOST-SL/host_pay
+Author-email: HostPay <host.sl.co@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: escrow,hostpay,mobile-money,payments,sdk,wallet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# HostPay Python SDK
+
+A small, typed client for the [HostPay](https://hpay.host-sl.com) payments API —
+wallets, deposits, transfers, payouts, escrow, and webhook verification.
+
+## Install
+
+```bash
+pip install hostpay          # once published
+# or, from this repo:
+pip install ./sdk/python
+```
+
+Requires Python 3.8+ and `httpx`.
+
+## Quickstart
+
+```python
+from hostpay import HostPay
+
+client = HostPay(api_key="ak-...", secret_key="sk-...")
+# Test Mode? use your test keys — same code, no real money moves.
+
+# 1. Create a user and their wallet
+user = client.users.create(
+    app_user_id="user_123",
+    name="Alice",
+    phone_number="+23279000000",
+    email="alice@example.com",
+)
+wallet = client.wallets.create(user.id)
+
+# 2. Deposit via mobile money
+deposit = client.deposits.mobile_money(wallet_id=wallet.id, amount=100)
+
+# 3. Check the balance (attribute or dict access)
+bal = client.wallets.balance(wallet.id)
+print(bal.balance, bal["currency"])
+
+# 4. Transfer, pay out, escrow
+client.transfers.create(sender_wallet_id=wallet.id, recipient_identifier="bob", amount=20)
+client.payouts.mobile_money(wallet_id=wallet.id, amount=5, phone_number="+23279000000")
+hold = client.escrow.hold(wallet_id=wallet.id, amount=10)
+client.escrow.release(hold.id, recipient_wallet_id="...")
+```
+
+## Authentication
+
+Pass your `api-key` and `secret-key` once at construction; they're sent on every
+request. `base_url` defaults to production — point it at your staging host for
+testing.
+
+## Idempotency
+
+Money-moving calls accept `idempotency_key` — reuse the same key to safely retry
+without double-charging:
+
+```python
+client.payouts.mobile_money(
+    wallet_id=w, amount=5, phone_number="+232...", idempotency_key="order-42-payout"
+)
+```
+
+## Verifying webhooks
+
+Pass the **raw** request body and headers straight from your web framework:
+
+```python
+from hostpay import HostPay, SignatureVerificationError
+
+client = HostPay(api_key="ak-...", secret_key="sk-...")
+
+# e.g. in Flask
+@app.post("/webhooks/hostpay")
+def hook():
+    try:
+        event = client.webhooks.construct_event(
+            payload=request.get_data(),          # raw bytes, not request.json
+            headers=request.headers,
+            secret=WEBHOOK_SIGNING_SECRET,
+        )
+    except SignatureVerificationError:
+        return "", 400
+    if event.event == "deposit.completed":
+        ...
+    return "", 200
+```
+
+Signatures are HMAC-SHA256 over `"<timestamp>.<body>"`; deliveries older than
+`tolerance` seconds (default 300) are rejected.
+
+## Errors
+
+All errors derive from `HostPayError` and carry `.status_code` and `.detail`:
+`AuthenticationError` (401/403), `InvalidRequestError` (400/404/422),
+`RateLimitError` (429), `APIError` (5xx), `APIConnectionError`,
+`SignatureVerificationError`.
+
+## Sandbox testing
+
+In Test Mode, a user's phone number drives deterministic outcomes (see the
+[Testing guide](https://hpay.host-sl.com/docs/guides/testing)): `+23299000001`
+completes, `+23299000002` fails, `+23299000009` stays pending. The same fail
+number works for payout recipients.
+
+## Typed responses
+
+Core methods are annotated with `TypedDict` models (`hostpay.models`): `users.*`
+return `UserRead`, `wallets.create/get` return `WalletRead`, `transfers`/
+`payouts` return `TransactionResponse`, and `escrow.*` returns `EscrowResponse`.
+A type checker (mypy/Pyright) will autocomplete and check keyed access —
+`user["id"]`, `wallet["balance"]`. Ad-hoc responses (wallet balance, the deposit
+envelope) stay loosely typed.
+
+At runtime every response is a `HostPayObject` (a dict), so both `resp["field"]`
+and `resp.field` work regardless of typing. The model fields mirror the committed
+[`../openapi.json`](../openapi.json), the source of truth for both SDKs —
+regenerate the spec with `python wallet-system/scripts/dump_openapi.py`.

hostpay-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+hostpay/__init__.py,sha256=lP2_uvYUvbHxe6mTs4E7AtuNH861l5qAut98WfO64mo,679
+hostpay/_client.py,sha256=EtsymRqIZTIk42DAY9_EAlfq936xjX441lN41jOM29A,4337
+hostpay/_object.py,sha256=-TCIuEAnWaB8Yb8O5_4vuPSmoOSrhldz-7BsuawIt7Q,906
+hostpay/errors.py,sha256=Av2Ep8gjufiQAYZD_pZIqeth66A42cfHeVAqNCD6tBA,1370
+hostpay/models.py,sha256=6U32wi3ChcmwtG7GwqU907snZMFrlv8vyi4gYUrf338,2244
+hostpay/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hostpay/resources.py,sha256=2rWkr9531P746NjI9rD1XmX88lWSAAMGY0xaiSz8Z3I,5183
+hostpay/webhooks.py,sha256=hNFjh9vvVxNFXoUpoX0SxS2KVRQQkqENS5jqCFTqSRI,2264
+hostpay-0.1.0.dist-info/METADATA,sha256=PVqFKLzL1plsyHfkaCtN-BX17tbUpX_nQX5O9r1ukwI,5010
+hostpay-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+hostpay-0.1.0.dist-info/licenses/LICENSE,sha256=35_f2J-v3CqSJIu6q71TJPv8l7fDZpxPN6SfxOC8g6w,1115
+hostpay-0.1.0.dist-info/RECORD,,

hostpay-0.1.0.dist-info/WHEEL

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

hostpay-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Heuristic of Science and Technology SL Limited ("HOST SL")
+
+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.