Simple API. Reliable delivery.

import os
import time
import uuid

import httpx


class Game SupplierClient:
    def __init__(self) -> None:
        self.http = httpx.Client(
            base_url="https://api.tg-gemesup.shop",
            headers={
                "Authorization": f"Bearer {os.environ['GAME_SUPPLIER_API_KEY']}",
                "Accept": "application/json",
            },
            timeout=30.0,
        )

    def request(self, method: str, path: str, **kwargs) -> dict:
        response = self.http.request(method, path, **kwargs)
        payload = response.json()
        if response.is_error:
            message = payload.get("message", "API request failed")
            raise RuntimeError(f"{response.status_code}: {message}")
        return payload

    def products(self, locale: str = "ru") -> list[dict]:
        return self.request(
            "GET",
            "/api/v1/products",
            params={"locale": locale},
        )["products"]

    @staticmethod
    def product_body(
        product_id: str,
        fields: dict[str, str],
        quantity: int | None = None,
    ) -> dict:
        body = {"product_id": product_id, "fields": fields}
        for key in ("player_id", "server_id"):
            if key in fields:
                body[key] = fields[key]
        if quantity is not None:
            body["quantity"] = quantity
        return body

    def check_player(
        self,
        product_id: str,
        fields: dict[str, str],
        quantity: int | None = None,
    ) -> dict:
        return self.request(
            "POST",
            "/api/v1/check-player",
            json=self.product_body(product_id, fields, quantity),
        )

    def create_order(
        self,
        product_id: str,
        fields: dict[str, str],
        partner_order_id: str,
        quantity: int | None = None,
    ) -> dict:
        key = uuid.uuid4().hex
        body = self.product_body(product_id, fields)
        body["partner_order_id"] = partner_order_id
        body["idempotency_key"] = key
        if quantity is not None:
            body["quantity"] = quantity

        for attempt in range(5):
            try:
                response = self.http.post("/api/v1/order", json=body)
            except httpx.TransportError:
                if attempt == 4:
                    raise
                time.sleep(2 ** attempt)
                continue

            if response.status_code >= 500 and attempt < 4:
                time.sleep(2 ** attempt)
                continue

            payload = response.json()
            if response.is_error:
                raise RuntimeError(
                    f"{response.status_code}: "
                    f"{payload.get('message', 'Order request failed')}"
                )
            return payload

        raise RuntimeError("Order request failed")

    def wait_order(self, order_id: int, timeout: int = 180) -> dict:
        terminal = {"completed", "refunded", "manual_review", "partial_completed"}
        deadline = time.monotonic() + timeout
        while time.monotonic() < deadline:
            order = self.request("GET", f"/api/v1/order/{order_id}")
            if order["status"] in terminal:
                return order
            time.sleep(3)
        raise TimeoutError(f"Order {order_id} is still processing")