tcgapi 0.2.1__py3-none-any.whl

tcgapi/resources/bulk.py

@@ -0,0 +1,140 @@
+"""BulkResource — /bulk/* endpoints. Auto-chunks oversized lists."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from ..models import BulkCard, BulkPriceRow, PriceHistoryPoint, Response
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+BULK_PRICES_MAX = 500
+BULK_CARDS_MAX = 100
+BULK_HISTORY_MAX = 50
+
+RangeLiteral = Literal["month", "quarter", "year", "all"]
+
+
+def _ids(ids: list[int]) -> str:
+    if not ids:
+        raise ValueError("At least one card ID required")
+    return ",".join(str(i) for i in ids)
+
+
+class BulkResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def prices(self, ids: list[int]) -> Response[list[BulkPriceRow]]:
+        if len(ids) <= BULK_PRICES_MAX:
+            body = self._client._request("GET", "/bulk/prices", {"ids": _ids(ids)})
+            return parse_response(list[BulkPriceRow], body)
+        rows: list[BulkPriceRow] = []
+        last: Response[list[BulkPriceRow]] | None = None
+        for i in range(0, len(ids), BULK_PRICES_MAX):
+            chunk = ids[i : i + BULK_PRICES_MAX]
+            body = self._client._request("GET", "/bulk/prices", {"ids": _ids(chunk)})
+            resp: Response[list[BulkPriceRow]] = parse_response(list[BulkPriceRow], body)
+            rows.extend(resp.data)
+            last = resp
+        return Response[list[BulkPriceRow]](data=rows, rate_limit=last.rate_limit if last else None)
+
+    def cards(self, ids: list[int]) -> Response[list[BulkCard]]:
+        if len(ids) <= BULK_CARDS_MAX:
+            body = self._client._request("GET", "/bulk/cards", {"ids": _ids(ids)})
+            return parse_response(list[BulkCard], body)
+        rows: list[BulkCard] = []
+        last: Response[list[BulkCard]] | None = None
+        for i in range(0, len(ids), BULK_CARDS_MAX):
+            chunk = ids[i : i + BULK_CARDS_MAX]
+            body = self._client._request("GET", "/bulk/cards", {"ids": _ids(chunk)})
+            resp: Response[list[BulkCard]] = parse_response(list[BulkCard], body)
+            rows.extend(resp.data)
+            last = resp
+        return Response[list[BulkCard]](data=rows, rate_limit=last.rate_limit if last else None)
+
+    def history(
+        self,
+        ids: list[int],
+        *,
+        range: RangeLiteral | None = None,
+        printing: str | None = None,
+    ) -> Response[dict[str, list[PriceHistoryPoint]]]:
+        params: dict[str, object | None] = {"range": range, "printing": printing}
+        if len(ids) <= BULK_HISTORY_MAX:
+            body = self._client._request("GET", "/bulk/history", {**params, "ids": _ids(ids)})
+            return parse_response(dict[str, list[PriceHistoryPoint]], body)
+        merged: dict[str, list[PriceHistoryPoint]] = {}
+        last: Response[dict[str, list[PriceHistoryPoint]]] | None = None
+        for i in range(0, len(ids), BULK_HISTORY_MAX):
+            chunk = ids[i : i + BULK_HISTORY_MAX]
+            body = self._client._request("GET", "/bulk/history", {**params, "ids": _ids(chunk)})
+            resp: Response[dict[str, list[PriceHistoryPoint]]] = parse_response(
+                dict[str, list[PriceHistoryPoint]], body
+            )
+            merged.update(resp.data)
+            last = resp
+        return Response[dict[str, list[PriceHistoryPoint]]](
+            data=merged, rate_limit=last.rate_limit if last else None
+        )
+
+
+class AsyncBulkResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def prices(self, ids: list[int]) -> Response[list[BulkPriceRow]]:
+        if len(ids) <= BULK_PRICES_MAX:
+            body = await self._client._request("GET", "/bulk/prices", {"ids": _ids(ids)})
+            return parse_response(list[BulkPriceRow], body)
+        rows: list[BulkPriceRow] = []
+        last: Response[list[BulkPriceRow]] | None = None
+        for i in range(0, len(ids), BULK_PRICES_MAX):
+            chunk = ids[i : i + BULK_PRICES_MAX]
+            body = await self._client._request("GET", "/bulk/prices", {"ids": _ids(chunk)})
+            resp: Response[list[BulkPriceRow]] = parse_response(list[BulkPriceRow], body)
+            rows.extend(resp.data)
+            last = resp
+        return Response[list[BulkPriceRow]](data=rows, rate_limit=last.rate_limit if last else None)
+
+    async def cards(self, ids: list[int]) -> Response[list[BulkCard]]:
+        if len(ids) <= BULK_CARDS_MAX:
+            body = await self._client._request("GET", "/bulk/cards", {"ids": _ids(ids)})
+            return parse_response(list[BulkCard], body)
+        rows: list[BulkCard] = []
+        last: Response[list[BulkCard]] | None = None
+        for i in range(0, len(ids), BULK_CARDS_MAX):
+            chunk = ids[i : i + BULK_CARDS_MAX]
+            body = await self._client._request("GET", "/bulk/cards", {"ids": _ids(chunk)})
+            resp: Response[list[BulkCard]] = parse_response(list[BulkCard], body)
+            rows.extend(resp.data)
+            last = resp
+        return Response[list[BulkCard]](data=rows, rate_limit=last.rate_limit if last else None)
+
+    async def history(
+        self,
+        ids: list[int],
+        *,
+        range: RangeLiteral | None = None,
+        printing: str | None = None,
+    ) -> Response[dict[str, list[PriceHistoryPoint]]]:
+        params: dict[str, object | None] = {"range": range, "printing": printing}
+        if len(ids) <= BULK_HISTORY_MAX:
+            body = await self._client._request("GET", "/bulk/history", {**params, "ids": _ids(ids)})
+            return parse_response(dict[str, list[PriceHistoryPoint]], body)
+        merged: dict[str, list[PriceHistoryPoint]] = {}
+        last: Response[dict[str, list[PriceHistoryPoint]]] | None = None
+        for i in range(0, len(ids), BULK_HISTORY_MAX):
+            chunk = ids[i : i + BULK_HISTORY_MAX]
+            body = await self._client._request("GET", "/bulk/history", {**params, "ids": _ids(chunk)})
+            resp: Response[dict[str, list[PriceHistoryPoint]]] = parse_response(
+                dict[str, list[PriceHistoryPoint]], body
+            )
+            merged.update(resp.data)
+            last = resp
+        return Response[dict[str, list[PriceHistoryPoint]]](
+            data=merged, rate_limit=last.rate_limit if last else None
+        )

tcgapi/resources/cards.py

@@ -0,0 +1,88 @@
+"""CardsResource — /cards endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from ..models import BulkCard, Card, Price, PriceHistoryPoint, Response
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+RangeLiteral = Literal["month", "quarter", "year", "all"]
+
+
+class CardsResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def get(self, card_id: int) -> Response[Card]:
+        body = self._client._request("GET", f"/cards/{card_id}")
+        return parse_response(Card, body)
+
+    def prices(self, card_id: int, *, printing: str | None = None) -> Response[list[Price]]:
+        body = self._client._request("GET", f"/cards/{card_id}/prices", {"printing": printing})
+        return parse_response(list[Price], body)
+
+    def by_tcgplayer_id(self, tcgplayer_id: int) -> Response[BulkCard]:
+        body = self._client._request("GET", f"/cards/tcgplayer/{tcgplayer_id}")
+        return parse_response(BulkCard, body)
+
+    def history(
+        self,
+        card_id: int,
+        *,
+        range: RangeLiteral | None = None,
+        printing: str | None = None,
+    ) -> Response[list[PriceHistoryPoint]]:
+        body = self._client._request(
+            "GET", f"/cards/{card_id}/history", {"range": range, "printing": printing}
+        )
+        return parse_response(list[PriceHistoryPoint], body)
+
+    def history_detailed(
+        self, card_id: int, *, printing: str | None = None
+    ) -> Response[list[PriceHistoryPoint]]:
+        body = self._client._request(
+            "GET", f"/cards/{card_id}/history/detailed", {"printing": printing}
+        )
+        return parse_response(list[PriceHistoryPoint], body)
+
+
+class AsyncCardsResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def get(self, card_id: int) -> Response[Card]:
+        body = await self._client._request("GET", f"/cards/{card_id}")
+        return parse_response(Card, body)
+
+    async def prices(self, card_id: int, *, printing: str | None = None) -> Response[list[Price]]:
+        body = await self._client._request("GET", f"/cards/{card_id}/prices", {"printing": printing})
+        return parse_response(list[Price], body)
+
+    async def by_tcgplayer_id(self, tcgplayer_id: int) -> Response[BulkCard]:
+        body = await self._client._request("GET", f"/cards/tcgplayer/{tcgplayer_id}")
+        return parse_response(BulkCard, body)
+
+    async def history(
+        self,
+        card_id: int,
+        *,
+        range: RangeLiteral | None = None,
+        printing: str | None = None,
+    ) -> Response[list[PriceHistoryPoint]]:
+        body = await self._client._request(
+            "GET", f"/cards/{card_id}/history", {"range": range, "printing": printing}
+        )
+        return parse_response(list[PriceHistoryPoint], body)
+
+    async def history_detailed(
+        self, card_id: int, *, printing: str | None = None
+    ) -> Response[list[PriceHistoryPoint]]:
+        body = await self._client._request(
+            "GET", f"/cards/{card_id}/history/detailed", {"printing": printing}
+        )
+        return parse_response(list[PriceHistoryPoint], body)

tcgapi/resources/export.py

@@ -0,0 +1,36 @@
+"""ExportResource — /export/set/{id}."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..models import BulkPriceRow, Response
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+
+class ExportResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def set_json(self, set_id: int) -> Response[list[BulkPriceRow]]:
+        body = self._client._request("GET", f"/export/set/{set_id}", {"format": "json"})
+        return parse_response(list[BulkPriceRow], body)
+
+    def set_csv(self, set_id: int) -> str:
+        return self._client._request_raw("GET", f"/export/set/{set_id}", {"format": "csv"})
+
+
+class AsyncExportResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def set_json(self, set_id: int) -> Response[list[BulkPriceRow]]:
+        body = await self._client._request("GET", f"/export/set/{set_id}", {"format": "json"})
+        return parse_response(list[BulkPriceRow], body)
+
+    async def set_csv(self, set_id: int) -> str:
+        return await self._client._request_raw("GET", f"/export/set/{set_id}", {"format": "csv"})

tcgapi/resources/games.py

@@ -0,0 +1,48 @@
+"""GamesResource — /games endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..models import Game, Response, Set
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+
+class GamesResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def list(self, *, page: int | None = None, per_page: int | None = None) -> Response[list[Game]]:
+        body = self._client._request("GET", "/games", {"page": page, "per_page": per_page})
+        return parse_response(list[Game], body)
+
+    def get(self, slug: str | int) -> Response[Game]:
+        body = self._client._request("GET", f"/games/{slug}")
+        return parse_response(Game, body)
+
+    def sets(self, slug: str | int, *, page: int | None = None, per_page: int | None = None) -> Response[list[Set]]:
+        body = self._client._request("GET", f"/games/{slug}/sets", {"page": page, "per_page": per_page})
+        return parse_response(list[Set], body)
+
+
+class AsyncGamesResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def list(self, *, page: int | None = None, per_page: int | None = None) -> Response[list[Game]]:
+        body = await self._client._request("GET", "/games", {"page": page, "per_page": per_page})
+        return parse_response(list[Game], body)
+
+    async def get(self, slug: str | int) -> Response[Game]:
+        body = await self._client._request("GET", f"/games/{slug}")
+        return parse_response(Game, body)
+
+    async def sets(
+        self, slug: str | int, *, page: int | None = None, per_page: int | None = None
+    ) -> Response[list[Set]]:
+        body = await self._client._request("GET", f"/games/{slug}/sets", {"page": page, "per_page": per_page})
+        return parse_response(list[Set], body)

tcgapi/resources/keys.py

@@ -0,0 +1,30 @@
+"""KeysResource — /keys (session-cookie auth, mostly used from the dashboard)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..models import ApiKeySummary, Response
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+
+class KeysResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def list(self) -> Response[list[ApiKeySummary]]:
+        body = self._client._request("GET", "/keys")
+        return parse_response(list[ApiKeySummary], body)
+
+
+class AsyncKeysResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def list(self) -> Response[list[ApiKeySummary]]:
+        body = await self._client._request("GET", "/keys")
+        return parse_response(list[ApiKeySummary], body)

tcgapi/resources/prices.py

@@ -0,0 +1,74 @@
+"""PricesResource — /prices/top-movers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from ..models import PriceMover, Response
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+DirectionLiteral = Literal["up", "down"]
+PeriodLiteral = Literal["24h", "7d", "30d"]
+TypeLiteral = Literal["Cards", "Sealed Products"]
+
+
+class PricesResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def top_movers(
+        self,
+        *,
+        game: str | None = None,
+        direction: DirectionLiteral | None = None,
+        period: PeriodLiteral | None = None,
+        printing: str | None = None,
+        type: TypeLiteral | None = None,
+        limit: int | None = None,
+    ) -> Response[list[PriceMover]]:
+        body = self._client._request(
+            "GET",
+            "/prices/top-movers",
+            {
+                "game": game,
+                "direction": direction,
+                "period": period,
+                "printing": printing,
+                "type": type,
+                "limit": limit,
+            },
+        )
+        return parse_response(list[PriceMover], body)
+
+
+class AsyncPricesResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def top_movers(
+        self,
+        *,
+        game: str | None = None,
+        direction: DirectionLiteral | None = None,
+        period: PeriodLiteral | None = None,
+        printing: str | None = None,
+        type: TypeLiteral | None = None,
+        limit: int | None = None,
+    ) -> Response[list[PriceMover]]:
+        body = await self._client._request(
+            "GET",
+            "/prices/top-movers",
+            {
+                "game": game,
+                "direction": direction,
+                "period": period,
+                "printing": printing,
+                "type": type,
+                "limit": limit,
+            },
+        )
+        return parse_response(list[PriceMover], body)

tcgapi/resources/search.py

@@ -0,0 +1,118 @@
+"""SearchResource — /search."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, AsyncIterator, Iterator, Literal
+
+from ..models import CardWithPrice, Response
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+SortLiteral = Literal["relevance", "price_asc", "price_desc", "name"]
+TypeLiteral = Literal["Cards", "Sealed Products"]
+
+
+def _params(
+    q: str,
+    game: str | None,
+    set_id: int | None,
+    rarity: str | None,
+    type: TypeLiteral | None,
+    printing: str | None,
+    min_price: float | None,
+    max_price: float | None,
+    sort: SortLiteral | None,
+    page: int | None,
+    per_page: int | None,
+) -> dict[str, object | None]:
+    return {
+        "q": q,
+        "game": game,
+        "set_id": set_id,
+        "rarity": rarity,
+        "type": type,
+        "printing": printing,
+        "min_price": min_price,
+        "max_price": max_price,
+        "sort": sort,
+        "page": page,
+        "per_page": per_page,
+    }
+
+
+class SearchResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def cards(
+        self,
+        q: str,
+        *,
+        game: str | None = None,
+        set_id: int | None = None,
+        rarity: str | None = None,
+        type: TypeLiteral | None = None,
+        printing: str | None = None,
+        min_price: float | None = None,
+        max_price: float | None = None,
+        sort: SortLiteral | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> Response[list[CardWithPrice]]:
+        body = self._client._request(
+            "GET",
+            "/search",
+            _params(q, game, set_id, rarity, type, printing, min_price, max_price, sort, page, per_page),
+        )
+        return parse_response(list[CardWithPrice], body)
+
+    def iter(self, q: str, **kwargs: object) -> Iterator[CardWithPrice]:
+        page = int(kwargs.pop("page", 1) or 1)  # type: ignore[arg-type]
+        per_page = min(200, int(kwargs.pop("per_page", 200) or 200))  # type: ignore[arg-type]
+        while True:
+            resp = self.cards(q, page=page, per_page=per_page, **kwargs)  # type: ignore[arg-type]
+            yield from resp.data
+            if not resp.meta or not resp.meta.has_more:
+                return
+            page += 1
+
+
+class AsyncSearchResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def cards(
+        self,
+        q: str,
+        *,
+        game: str | None = None,
+        set_id: int | None = None,
+        rarity: str | None = None,
+        type: TypeLiteral | None = None,
+        printing: str | None = None,
+        min_price: float | None = None,
+        max_price: float | None = None,
+        sort: SortLiteral | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> Response[list[CardWithPrice]]:
+        body = await self._client._request(
+            "GET",
+            "/search",
+            _params(q, game, set_id, rarity, type, printing, min_price, max_price, sort, page, per_page),
+        )
+        return parse_response(list[CardWithPrice], body)
+
+    async def iter(self, q: str, **kwargs: object) -> AsyncIterator[CardWithPrice]:
+        page = int(kwargs.pop("page", 1) or 1)  # type: ignore[arg-type]
+        per_page = min(200, int(kwargs.pop("per_page", 200) or 200))  # type: ignore[arg-type]
+        while True:
+            resp = await self.cards(q, page=page, per_page=per_page, **kwargs)  # type: ignore[arg-type]
+            for card in resp.data:
+                yield card
+            if not resp.meta or not resp.meta.has_more:
+                return
+            page += 1

tcgapi/resources/sets.py

@@ -0,0 +1,115 @@
+"""SetsResource — /sets endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, AsyncIterator, Iterator, Literal
+
+from ..models import BulkPriceRow, CardWithPrice, Response, Set
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+SortLiteral = Literal["number", "price_asc", "price_desc", "name"]
+TypeLiteral = Literal["Cards", "Sealed Products"]
+
+
+class SetsResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        game: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> Response[list[Set]]:
+        body = self._client._request("GET", "/sets", {"game": game, "page": page, "per_page": per_page})
+        return parse_response(list[Set], body)
+
+    def get(self, set_id: int) -> Response[Set]:
+        body = self._client._request("GET", f"/sets/{set_id}")
+        return parse_response(Set, body)
+
+    def cards(
+        self,
+        set_id: int,
+        *,
+        type: TypeLiteral | None = None,
+        sort: SortLiteral | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> Response[list[CardWithPrice]]:
+        body = self._client._request(
+            "GET",
+            f"/sets/{set_id}/cards",
+            {"type": type, "sort": sort, "page": page, "per_page": per_page},
+        )
+        return parse_response(list[CardWithPrice], body)
+
+    def prices(self, set_id: int) -> Response[list[BulkPriceRow]]:
+        body = self._client._request("GET", f"/sets/{set_id}/prices")
+        return parse_response(list[BulkPriceRow], body)
+
+    def iter_cards(self, set_id: int, **params: object) -> Iterator[CardWithPrice]:
+        """Paginate through every card in a set, yielding one at a time."""
+        page = int(params.pop("page", 1) or 1)  # type: ignore[arg-type]
+        per_page = min(200, int(params.pop("per_page", 200) or 200))  # type: ignore[arg-type]
+        while True:
+            resp = self.cards(set_id, page=page, per_page=per_page, **params)  # type: ignore[arg-type]
+            yield from resp.data
+            if not resp.meta or not resp.meta.has_more:
+                return
+            page += 1
+
+
+class AsyncSetsResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def list(
+        self,
+        *,
+        game: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> Response[list[Set]]:
+        body = await self._client._request("GET", "/sets", {"game": game, "page": page, "per_page": per_page})
+        return parse_response(list[Set], body)
+
+    async def get(self, set_id: int) -> Response[Set]:
+        body = await self._client._request("GET", f"/sets/{set_id}")
+        return parse_response(Set, body)
+
+    async def cards(
+        self,
+        set_id: int,
+        *,
+        type: TypeLiteral | None = None,
+        sort: SortLiteral | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+    ) -> Response[list[CardWithPrice]]:
+        body = await self._client._request(
+            "GET",
+            f"/sets/{set_id}/cards",
+            {"type": type, "sort": sort, "page": page, "per_page": per_page},
+        )
+        return parse_response(list[CardWithPrice], body)
+
+    async def prices(self, set_id: int) -> Response[list[BulkPriceRow]]:
+        body = await self._client._request("GET", f"/sets/{set_id}/prices")
+        return parse_response(list[BulkPriceRow], body)
+
+    async def iter_cards(self, set_id: int, **params: object) -> AsyncIterator[CardWithPrice]:
+        page = int(params.pop("page", 1) or 1)  # type: ignore[arg-type]
+        per_page = min(200, int(params.pop("per_page", 200) or 200))  # type: ignore[arg-type]
+        while True:
+            resp = await self.cards(set_id, page=page, per_page=per_page, **params)  # type: ignore[arg-type]
+            for card in resp.data:
+                yield card
+            if not resp.meta or not resp.meta.has_more:
+                return
+            page += 1

tcgapi/resources/usage.py

@@ -0,0 +1,30 @@
+"""UsageResource — /usage."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..models import Response, UsageResponse
+from ._base import parse_response
+
+if TYPE_CHECKING:
+    from ..async_client import AsyncTCGApi
+    from ..client import TCGApi
+
+
+class UsageResource:
+    def __init__(self, client: "TCGApi") -> None:
+        self._client = client
+
+    def get(self) -> Response[UsageResponse]:
+        body = self._client._request("GET", "/usage")
+        return parse_response(UsageResponse, body)
+
+
+class AsyncUsageResource:
+    def __init__(self, client: "AsyncTCGApi") -> None:
+        self._client = client
+
+    async def get(self) -> Response[UsageResponse]:
+        body = await self._client._request("GET", "/usage")
+        return parse_response(UsageResponse, body)