copart-api 0.1.0__py3-none-any.whl

copart_api/__init__.py

@@ -0,0 +1,72 @@
+"""Copart API client for Python: Copart auction lots (USA) with VIN, damage and sale date as JSON.
+
+A thin layer over the apiauto.space client (``apiauto``) with the market preset::
+
+    import copart_api
+
+    with copart_api.Client() as client:  # the key comes from APIAUTO_KEY
+        for car in client.cars(brand="Toyota", year_min=2020, limit=20)["items"]:
+            print(car["id"], car["title"], car["price"]["amount"])
+
+From the apiauto.space team. Not affiliated with Copart.
+"""
+
+from apiauto import (
+    ApiautoError,
+    APIConnectionError,
+    AuthenticationError,
+    BadRequestError,
+    Car,
+    CarFilters,
+    CarsPage,
+    Change,
+    ChangesPage,
+    ChangeType,
+    Market,
+    NotFoundError,
+    PermissionDeniedError,
+    Price,
+    QuotaExceededError,
+    RateLimitError,
+    ReferenceItem,
+    ServerError,
+    ServiceUnavailableError,
+    Usage,
+)
+
+from ._client import MARKET, SHARED_MARKET, SOURCE, AsyncClient, Client, car_id
+from ._version import __version__
+from .types import CopartRaw, FxQuote, raw
+
+__all__ = [
+    "MARKET",
+    "SHARED_MARKET",
+    "SOURCE",
+    "APIConnectionError",
+    "ApiautoError",
+    "AsyncClient",
+    "AuthenticationError",
+    "BadRequestError",
+    "Car",
+    "CarFilters",
+    "CarsPage",
+    "Change",
+    "ChangeType",
+    "ChangesPage",
+    "Client",
+    "CopartRaw",
+    "FxQuote",
+    "Market",
+    "NotFoundError",
+    "PermissionDeniedError",
+    "Price",
+    "QuotaExceededError",
+    "RateLimitError",
+    "ReferenceItem",
+    "ServerError",
+    "ServiceUnavailableError",
+    "Usage",
+    "__version__",
+    "car_id",
+    "raw",
+]

copart_api/_client.py

@@ -0,0 +1,342 @@
+"""Copart clients: the apiauto clients with the market preset to ``us``."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator, Sequence
+from datetime import datetime
+from decimal import Decimal
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Literal
+
+import apiauto
+from apiauto import (
+    Car,
+    CarsPage,
+    Change,
+    ChangesPage,
+    ChangeType,
+    Dictionaries,
+    Market,
+    ReferenceItem,
+    Usage,
+)
+
+if TYPE_CHECKING:
+    import httpx
+    from apiauto import CarFilters
+    from typing_extensions import Self, Unpack
+
+MARKET: Literal["us"] = "us"
+"""The apiauto.space market of Copart."""
+SOURCE: Literal["copart"] = "copart"
+"""The ``source`` of every record this package returns."""
+SHARED_MARKET = True
+"""``True`` when the market also holds another source and records are filtered on the client."""
+
+
+def car_id(listing: str | int) -> str:
+    """The full record id for a Copart listing number: ``68055056`` -> ``copart:68055056``.
+
+    An id that already has the ``copart:`` prefix is returned as is; another
+    source's prefix raises ``ValueError``.
+    """
+    text = str(listing).strip()
+    if not text:
+        raise ValueError("listing must not be empty")
+    prefix, sep, number = text.partition(":")
+    if not sep:
+        return f"{SOURCE}:{text}"
+    if prefix != SOURCE or not number:
+        raise ValueError(f"not a Copart id: {text!r}")
+    return text
+
+
+def _ours(car: Car) -> bool:
+    return car.get("source") == SOURCE
+
+
+def _our_change(change: Change) -> bool:
+    return change["car_id"].startswith(SOURCE + ":")
+
+
+def _core_options(base_url: str | None) -> dict[str, Any]:
+    return {} if base_url is None else {"base_url": base_url}
+
+
+def _own_market(markets: list[Market]) -> Market:
+    for market in markets:
+        if market["market"] == MARKET:
+            return market
+    raise apiauto.ApiautoError(f"the API did not list the {MARKET} market")
+
+
+class Client:
+    """Copart client of the apiauto.space API, synchronous.
+
+    Args:
+        api_key: Your key; defaults to the ``APIAUTO_KEY`` environment variable.
+        base_url: The API root; ``https://api.apiauto.space/v1`` when omitted.
+        timeout: Seconds to wait for a response.
+        max_retries: Retries after 429, 5xx or a network error.
+        http_client: Your own ``httpx.Client``; the client does not close it.
+
+    Use it as a context manager or call :meth:`close`::
+
+        with copart_api.Client() as client:
+            page = client.cars(brand="Toyota", limit=20)
+
+    The general client is available as :attr:`core` for anything this one does not wrap.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        self.core = apiauto.Client(
+            api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            http_client=http_client,
+            **_core_options(base_url),
+        )
+
+    def close(self) -> None:
+        """Close the HTTP connections (unless the ``http_client`` was yours)."""
+        self.core.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def cars(self, **filters: Unpack[CarFilters]) -> CarsPage:
+        """One page of Copart cars: ``GET /cars?market=us``.
+
+        Takes the filters of :meth:`apiauto.Client.cars`: ``brand``, ``model``, ``year_min``,
+        ``year_max``, ``price_min``, ``price_max`` (in USD), ``mileage_max``, ``sort``,
+        ``limit``, ``cursor`` and more. Every car returned counts against the quota.
+        """
+        page = self.core.cars(MARKET, **filters)
+        # The us market mixes Copart and IAAI: keep this source's lots. The page can hold
+        # fewer than `limit` cars, and `count` is unknown for one source.
+        return {
+            "items": [car for car in page["items"] if _ours(car)],
+            "next_cursor": page["next_cursor"],
+            "count": None,
+        }
+
+    def iter_cars(self, *, max_items: int | None = None, **filters: Unpack[CarFilters]) -> Iterator[Car]:
+        """Every Copart car matching the filters, following ``next_cursor``.
+
+        Args:
+            max_items: Stop after this many cars.
+            **filters: The filters of :meth:`cars`; ``limit`` sets the page size.
+        """
+        if max_items is not None and max_items <= 0:
+            return
+        taken = 0
+        for car in self.core.iter_cars(MARKET, **filters):
+            if _ours(car):
+                yield car
+                taken += 1
+                if max_items is not None and taken >= max_items:
+                    return
+
+    def car(self, listing: str | int) -> Car:
+        """One car by listing number (``68055056``) or record id (``copart:68055056``).
+
+        Cars taken off sale stay available for 14 days with ``is_active=False``.
+        """
+        return self.core.car(car_id(listing))
+
+    def changes(
+        self,
+        since: datetime | str,
+        *,
+        type: ChangeType | Sequence[ChangeType] | None = None,  # noqa: A002
+        min_pct: float | Decimal | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> ChangesPage:
+        """One page of the change feed: new cars, cars taken off sale and price changes since a moment."""
+        page = self.core.changes(MARKET, since, type=type, min_pct=min_pct, limit=limit, cursor=cursor)
+        return {
+            "items": [change for change in page["items"] if _our_change(change)],
+            "next_cursor": page["next_cursor"],
+        }
+
+    def iter_changes(
+        self,
+        since: datetime | str,
+        *,
+        type: ChangeType | Sequence[ChangeType] | None = None,  # noqa: A002
+        min_pct: float | Decimal | None = None,
+        limit: int | None = None,
+        max_items: int | None = None,
+    ) -> Iterator[Change]:
+        """Every event of the change feed since a moment, following ``next_cursor``."""
+        if max_items is not None and max_items <= 0:
+            return
+        taken = 0
+        for change in self.core.iter_changes(MARKET, since, type=type, min_pct=min_pct, limit=limit):
+            if _our_change(change):
+                yield change
+                taken += 1
+                if max_items is not None and taken >= max_items:
+                    return
+
+    def brands(self) -> list[ReferenceItem]:
+        """Makes of the us market with car counts, most frequent first. Free."""
+        return self.core.brands(MARKET)
+
+    def models(self, brand: str) -> list[ReferenceItem]:
+        """Models of a make with car counts. Free."""
+        return self.core.models(MARKET, brand)
+
+    def dictionaries(self) -> Dictionaries:
+        """Canonical values of ``fuel``, ``transmission``, ``body_type`` and more. Free."""
+        return self.core.dictionaries()
+
+    def status(self) -> Market:
+        """The us market: plan access, data age and the number of active cars. Free."""
+        return _own_market(self.core.markets())
+
+    def usage(self) -> Usage:
+        """The plan, its term and how much of the quota is spent. Free."""
+        return self.core.usage()
+
+    def live(
+        self,
+        *,
+        make: str | None = None,
+        model: str | None = None,
+        year_min: int | None = None,
+        year_max: int | None = None,
+        price_max: int | None = None,
+        page: int | None = None,
+    ) -> list[Car]:
+        """Search lots live at the auction data provider: ``GET /us/live``, this source's lots only.
+
+        For lots that are not in the catalog copy yet. Pro and Max plans; it spends a
+        separate monthly counter. ``price_max`` is in US dollars, ``page`` is 1-100.
+        """
+        lots = self.core.us_live(
+            make=make, model=model, year_min=year_min, year_max=year_max, price_max=price_max, page=page
+        )
+        return [car for car in lots if _ours(car)]
+
+
+class AsyncClient:
+    """Copart client of the apiauto.space API for asyncio; the methods of :class:`Client`.
+
+    ::
+
+        async with copart_api.AsyncClient() as client:
+            page = await client.cars(brand="Toyota", limit=20)
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.core = apiauto.AsyncClient(
+            api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            http_client=http_client,
+            **_core_options(base_url),
+        )
+
+    async def close(self) -> None:
+        """Close the HTTP connections (unless the ``http_client`` was yours)."""
+        await self.core.close()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def cars(self, **filters: Unpack[CarFilters]) -> CarsPage:
+        """One page of Copart cars; see :meth:`Client.cars`."""
+        page = await self.core.cars(MARKET, **filters)
+        return {
+            "items": [car for car in page["items"] if _ours(car)],
+            "next_cursor": page["next_cursor"],
+            "count": None,
+        }
+
+    async def iter_cars(
+        self, *, max_items: int | None = None, **filters: Unpack[CarFilters]
+    ) -> AsyncIterator[Car]:
+        """Every Copart car matching the filters; see :meth:`Client.iter_cars`."""
+        if max_items is not None and max_items <= 0:
+            return
+        taken = 0
+        async for car in self.core.iter_cars(MARKET, **filters):
+            if _ours(car):
+                yield car
+                taken += 1
+                if max_items is not None and taken >= max_items:
+                    return
+
+    async def car(self, listing: str | int) -> Car:
+        """One car by listing number or record id; see :meth:`Client.car`."""
+        return await self.core.car(car_id(listing))
+
+    async def changes(
+        self,
+        since: datetime | str,
+        *,
+        type: ChangeType | Sequence[ChangeType] | None = None,  # noqa: A002
+        min_pct: float | Decimal | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> ChangesPage:
+        """One page of the change feed; see :meth:`Client.changes`."""
+        page = await self.core.changes(MARKET, since, type=type, min_pct=min_pct, limit=limit, cursor=cursor)
+        return {
+            "items": [change for change in page["items"] if _our_change(change)],
+            "next_cursor": page["next_cursor"],
+        }
+
+    async def brands(self) -> list[ReferenceItem]:
+        """Makes of the us market with car counts. Free."""
+        return await self.core.brands(MARKET)
+
+    async def models(self, brand: str) -> list[ReferenceItem]:
+        """Models of a make with car counts. Free."""
+        return await self.core.models(MARKET, brand)
+
+    async def dictionaries(self) -> Dictionaries:
+        """Canonical values of ``fuel``, ``transmission``, ``body_type`` and more. Free."""
+        return await self.core.dictionaries()
+
+    async def status(self) -> Market:
+        """The us market: plan access, data age and the number of active cars. Free."""
+        return _own_market(await self.core.markets())
+
+    async def usage(self) -> Usage:
+        """The plan, its term and how much of the quota is spent. Free."""
+        return await self.core.usage()

copart_api/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

copart_api/types.py

@@ -0,0 +1,77 @@
+"""Types of the Copart-only fields of a record.
+
+Every record has the same common keys in every market (see :class:`apiauto.Car`);
+the fields only Copart has are in ``car["raw"]``. :func:`raw` returns them typed::
+
+    from copart_api import raw
+
+    extra = raw(car)
+    print(extra.get("source_values"))
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypedDict, cast
+
+from apiauto import Car
+
+__all__ = ["CopartRaw", "FxQuote", "raw"]
+
+
+class FxQuote(TypedDict):
+    """The ECB daily rate behind ``price_usd``."""
+
+    currency: str
+    usd_per_unit: str
+    """Decimal string: US dollars for one unit of ``currency``."""
+    date: str
+    source: str
+
+
+class CopartRaw(TypedDict, total=False):
+    """Copart-only fields of a record (``car["raw"]``). Keys can be missing; read them with ``.get``."""
+
+    lot_number: str | None
+    """The lot number at the auction."""
+    status: int | None
+    sale_date: str | None
+    """Auction date and time, ISO 8601."""
+    bid: int | float | None
+    """The current bid, US dollars."""
+    buy_now: int | float | None
+    """Buy-now price, US dollars."""
+    final_bid: int | float | None
+    """The final bid of a sold lot, US dollars."""
+    damage_main: str | None
+    """Primary damage, a canonical value such as ``front`` or ``rear``."""
+    damage_second: str | None
+    title_doc: str | None
+    """Title document type, a canonical value such as ``clean`` or ``salvage``."""
+    keys_available: bool | None
+    airbags: Any
+    odometer_mi: int | None
+    """Odometer in miles as the auction shows it (``mileage_km`` is converted)."""
+    odometer_status: Any
+    condition: Any
+    grade_iaai: Any
+    estimate_repair_price: int | float | None
+    pre_accident_price: int | float | None
+    clean_wholesale_price: int | float | None
+    seller: str | None
+    seller_type: Any
+    location_branch: str | None
+    """The auction yard, for example ``Nashville (TN)``."""
+    latitude: float | None
+    longitude: float | None
+    video_url: str | None
+    drive: str | None
+    """``fwd``, ``rwd``, ``awd`` or ``4wd``."""
+    cylinders: int | None
+    source_values: dict[str, str | None]
+    """The auction's own spellings of make, model, fuel, damage and more."""
+    fx: FxQuote | None
+
+
+def raw(car: Car) -> CopartRaw:
+    """The Copart-only fields of a record, typed as :class:`CopartRaw`."""
+    return cast(CopartRaw, car.get("raw") or {})

copart_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.5
+Name: copart-api
+Version: 0.1.0
+Summary: Copart API client for Python: Copart auction lots (USA) with VIN, damage and sale date as JSON, from the apiauto.space team
+Project-URL: Homepage, https://apiauto.space/en/copart-api/
+Project-URL: Documentation, https://apiauto.space/en/docs/
+Project-URL: Repository, https://github.com/apiauto-space/copart-api
+Project-URL: Issues, https://github.com/apiauto-space/copart-api/issues
+Project-URL: Changelog, https://github.com/apiauto-space/copart-api/blob/main/python/CHANGELOG.md
+Project-URL: Get a demo key, https://t.me/apiautospace_bot?start=demo
+Author: apiauto.space
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api client,car auction,copart,copart api,salvage cars,usa cars,used cars,vehicle data,vin
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: apiauto-space<0.2,>=0.1.1
+Description-Content-Type: text/markdown
+
+# copart-api — Copart API client for Python
+
+[![PyPI version](https://img.shields.io/pypi/v/copart-api.svg)](https://pypi.org/project/copart-api/)
+[![Python versions](https://img.shields.io/pypi/pyversions/copart-api.svg)](https://pypi.org/project/copart-api/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/apiauto-space/copart-api/blob/main/LICENSE)
+
+`copart-api` gives you Copart auction lots (USA) with VIN, damage and sale date as clean JSON through the [apiauto.space](https://apiauto.space/en/copart-api/)
+REST API, without writing or maintaining a scraper. Search by make, model, year, price and mileage, page
+through the whole catalog, fetch one listing by its number and follow a feed of new cars, cars taken off sale
+and price changes.
+
+It is a thin layer over the general [`apiauto-space`](https://pypi.org/project/apiauto-space/) client with
+the market preset to `us`, plus types for the Copart-only fields. It comes from the apiauto.space team;
+the project is not affiliated with Copart.
+
+- Sync `Client` and `AsyncClient`, retries on 429 and 5xx, one exception class per API error
+- `car("68055056")` takes the Copart listing number as well as the record id
+- `CopartRaw` types for the Copart-only fields in `car["raw"]`
+- Python 3.10+, `py.typed`, checked with `mypy --strict`
+
+## Install
+
+```bash
+pip install copart-api
+```
+
+The module you import is `copart_api`.
+
+## Get a key
+
+Open the Telegram bot [@apiautospace_bot](https://t.me/apiautospace_bot?start=demo) and take a free demo
+key: one day, 100 data requests, up to 20 cars per request. Paid plans are on the
+[pricing page](https://apiauto.space/en/#pricing).
+
+Save the key in the `APIAUTO_KEY` environment variable — the client reads it from there:
+
+```bash
+export APIAUTO_KEY="your-key"
+```
+
+Keep the key on your server: the API does not accept browser requests.
+
+## Quick start
+
+```python
+import copart_api
+
+with copart_api.Client() as client:  # reads APIAUTO_KEY
+    page = client.cars(brand="Toyota", year_min=2020, limit=20)
+    for car in page["items"]:
+        print(car["id"], car["title"], car["price"]["amount"], car["price"]["currency"])
+
+    one = client.car("68055056")  # a listing number or "copart:68055056"
+    print(one["listing_url"], one["photos"][:1])
+```
+
+A record looks like this (shortened; real values from the catalog):
+
+```json
+{
+  "id": "copart:68055056",
+  "market": "us",
+  "source": "copart",
+  "source_id": "68055056",
+  "title": "2019 Hyundai Elantra",
+  "brand": "Hyundai",
+  "model": "Elantra",
+  "year": 2019,
+  "mileage_km": 239240,
+  "fuel": "gasoline",
+  "transmission": "automatic",
+  "body_type": null,
+  "vin": "5NPD84LF8KH406860",
+  "price": {
+    "amount": "4000.00",
+    "currency": "USD"
+  },
+  "price_usd": "4000.00",
+  "location": {
+    "country": "US",
+    "region": "TN",
+    "city": "Nashville"
+  },
+  "listing_url": null,
+  "is_active": true,
+  "first_seen_at": "2026-09-23T00:21:16.304888Z",
+  "photos": [
+    "https://api.apiauto.space/img/copart:68055056/1.jpg?exp=...&sig=..."
+  ],
+  "raw": {
+    "lot_number": "68055056",
+    "sale_date": "2026-09-28T17:00:00+00:00",
+    "buy_now": 4000,
+    "damage_main": "front",
+    "title_doc": "clean",
+    "location_branch": "Nashville (TN)"
+  }
+}
+```
+
+Every record has the same keys as in the other apiauto.space markets; a value the source does not provide is
+`None`. Prices are decimal strings in USD, `price_usd` is converted at the ECB daily rate.
+
+## Copart and IAAI share one market
+
+The API keeps Copart and IAAI lots together in the `us` market and does not filter by auction yet. This client
+asks for `us` cars and keeps only Copart lots on the client side. What that means for you:
+
+- a page from `cars()` can hold fewer than `limit` lots, and its `count` is `None`;
+- the IAAI lots that were dropped still count against your quota;
+- `iter_cars(max_items=...)` reads pages until it has collected `max_items` Copart lots.
+
+When you need both auctions, use the general `apiauto` client with `client.cars("us")`.
+
+## Methods
+
+| Method | What it does | Quota |
+|---|---|---|
+| `cars(**filters)` | One page of Copart cars: `brand`, `model`, `year_min`, `year_max`, `price_min`, `price_max`, `mileage_max`, `fuel`, `body_type`, `sort`, `limit`, `cursor` | Cars returned |
+| `iter_cars(max_items=None, **filters)` | Every matching car, page after page | Cars returned |
+| `car(listing)` | One car by listing number or id, including cars taken off sale in the last 14 days | 1 record |
+| `changes(since, type=None)` / `iter_changes(...)` | Feed of `added`, `disappeared`, `price_drop`, `price_up` events | Events returned |
+| `brands()` / `models(brand)` | Makes and models with car counts | Free |
+| `status()` | Plan access, data age and the number of active cars of the market | Free |
+| `usage()` | Your plan, its term and the quota spent | Free |
+| `live(make=..., model=...)` | Live search at the auction data provider for lots not in the catalog yet, Pro and Max plans | Separate counter |
+
+The general client is at `client.core` for anything else. Errors are the `apiauto` exceptions, re-exported
+here: `QuotaExceededError`, `RateLimitError`, `NotFoundError`, `AuthenticationError` and the rest.
+
+## Copart-only fields
+
+```python
+from copart_api import raw
+
+extra = raw(car)  # typed as CopartRaw
+print(extra.get("source_values"))
+```
+
+`CopartRaw` lists the keys with comments; every key is optional, so read them with `.get`.
+
+## Links
+
+- [Copart API on apiauto.space](https://apiauto.space/en/copart-api/) and the [API documentation](https://apiauto.space/en/docs/)
+- [`apiauto-space`](https://pypi.org/project/apiauto-space/): the general client for all markets
+- Clients for the other sources: [`encar-api-client`](https://pypi.org/project/encar-api-client/), [`che168-api`](https://pypi.org/project/che168-api/), [`iaai-api`](https://pypi.org/project/iaai-api/)
+- [Examples in curl, Python, JavaScript and PHP](https://github.com/apiauto-space/copart-api-examples)
+- The JavaScript version of this client: [`copart-api` on npm](https://www.npmjs.com/package/copart-api)
+
+## License
+
+MIT. Copart is a trademark of its owner; it is named here only to say which listings the client returns.

copart_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+copart_api/__init__.py,sha256=Q2qLCWuCf4kBWNG3CrKVSSbpCsWTTy2ZGV6tnxmC1UM,1609
+copart_api/_client.py,sha256=iNhKE1jF9RLFvV9lvcbhD4sgPYFSU_60Q9TnpT07shM,11886
+copart_api/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+copart_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+copart_api/types.py,sha256=urg0g-YyJHCUKxmBo5bn_nUB6fyLf0RjiCaU_kfKpXg,2415
+copart_api-0.1.0.dist-info/METADATA,sha256=Qn47wyHNw_RCFcUYrtpUXc1vcveOE2-49dGORbi3RpQ,7749
+copart_api-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+copart_api-0.1.0.dist-info/licenses/LICENSE,sha256=Y2nBbdQFY450rUAs9rX-L1yEwSx3HF9qivxUwxCu_kI,1070
+copart_api-0.1.0.dist-info/RECORD,,

copart_api-0.1.0.dist-info/WHEEL

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

copart_api-0.1.0.dist-info/licenses/LICENSE

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