bbox-api 0.1.0__py3-none-any.whl

bbox_api/const.py

@@ -0,0 +1,31 @@
+"""Constants for the Bbox router API."""
+
+API_PATH = "api/v1"
+
+#: Default hostname of a Bbox on the local network.
+DEFAULT_HOST = "bbox.lan"
+
+#: Default IP address of a Bbox on the local network
+#: (192.168.1.1 on recent models, 192.168.1.254 on older ones).
+DEFAULT_IP = "192.168.1.1"
+
+#: Alternate hostname the Bbox answers on the LAN: the router hijacks DNS for
+#: it (mabbox.bytel.fr.lan -> its own LAN IP) and serves a valid certificate
+#: for this name. It only works from the local network, NOT from the internet.
+MABBOX_HOST = "mabbox.bytel.fr"
+
+#: Remote (WAN) access goes through the router's public IP, not mabbox.bytel.fr:
+#: https://<wan-ip>/api/v1, with the "remote access" option enabled on the box.
+#: Discover the WAN IP from the LAN with ``get_wan_ip().ipaddress``.
+
+DEFAULT_TIMEOUT = 10
+
+#: Conservative validity assumed for a btoken when the router omits or
+#: returns an unparseable "expires" (real tokens live ~20 min).
+TOKEN_FALLBACK_TTL = 60
+
+#: Endpoints that must be called without a ``btoken`` query parameter.
+NO_TOKEN_ENDPOINTS = frozenset({"login", "logout", "device/token"})
+
+#: Reasons returned by the API in its error envelope that are worth retrying.
+TEMPORARY_ERROR_REASONS = frozenset({"cannot extract request parameters"})

bbox_api/exceptions.py

@@ -0,0 +1,75 @@
+"""Exceptions raised by the Bbox API client.
+
+Typical mapping in an application: ``BboxInvalidCredentialsError`` /
+``BboxSessionExpiredError`` -> "authentication failed", ``BboxConnectionError``
+/ ``BboxTimeoutError`` -> "retry later / not ready".
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class BboxApiError(Exception):
+    """Base exception for all Bbox API errors."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        errors: list[dict[str, Any]] | None = None,
+    ) -> None:
+        """Initialize the error with an optional HTTP status and API error list."""
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.errors = errors or []
+
+
+class BboxConnectionError(BboxApiError):
+    """The router could not be reached (DNS failure, refused connection...)."""
+
+
+class BboxTimeoutError(BboxApiError):
+    """A request to the router timed out."""
+
+    def __init__(self, message: str = "Request to the Bbox timed out") -> None:
+        """Initialize the timeout error."""
+        super().__init__(message)
+
+
+class BboxAuthenticationError(BboxApiError):
+    """Authentication with the router failed or is missing."""
+
+
+class BboxInvalidCredentialsError(BboxAuthenticationError):
+    """The admin password is wrong (HTTP 401 on /login)."""
+
+    def __init__(self, message: str = "Invalid Bbox admin password") -> None:
+        """Initialize the invalid credentials error."""
+        super().__init__(message, status_code=401)
+
+
+class BboxSessionExpiredError(BboxAuthenticationError):
+    """The session cookie expired and re-authentication did not succeed."""
+
+    def __init__(self, message: str = "Bbox session expired") -> None:
+        """Initialize the session expired error."""
+        super().__init__(message, status_code=401)
+
+
+class BboxRateLimitError(BboxApiError):
+    """Too many login attempts: the router temporarily blocks authentication."""
+
+    def __init__(self, message: str = "Too many login attempts, rate limited") -> None:
+        """Initialize the rate limit error."""
+        super().__init__(message, status_code=429)
+
+
+class BboxNotFoundError(BboxApiError):
+    """The requested endpoint does not exist on this router/firmware."""
+
+    def __init__(self, message: str = "Endpoint not found on the Bbox") -> None:
+        """Initialize the not found error."""
+        super().__init__(message, status_code=404)

bbox_api/models.py

@@ -0,0 +1,412 @@
+"""Typed data models for the Bbox router API responses.
+
+All models are deliberately tolerant: unknown keys are preserved in ``raw``,
+missing or malformed keys fall back to the field default, so a firmware update
+changing the API payload is unlikely to break parsing. API keys are mapped to
+snake_case attributes through the ``alias`` field metadata.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import types
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from functools import cache
+from typing import Any, Self, Union, cast, get_args, get_origin, get_type_hints
+
+
+def fix_mojibake(value: str) -> str:
+    """Repair strings mis-decoded by the router (UTF-8 sent as latin-1)."""
+    try:
+        return value.encode("latin-1").decode("utf-8")
+    except (UnicodeDecodeError, UnicodeEncodeError):
+        return value
+
+
+def _to_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return value != 0
+    return str(value).strip().lower() in ("1", "true", "yes", "on")
+
+
+def _to_int(value: Any) -> int:
+    return int(float(value))
+
+
+def _to_float(value: Any) -> float:
+    return float(value)
+
+
+def _to_datetime(value: Any) -> datetime:
+    if isinstance(value, datetime):
+        return value if value.tzinfo else value.replace(tzinfo=UTC)
+    if isinstance(value, (int, float)):
+        return datetime.fromtimestamp(value, tz=UTC)
+    text = str(value).strip()
+    if text.endswith("Z"):
+        text = text[:-1] + "+00:00"
+    parsed = datetime.fromisoformat(text)  # raises ValueError on garbage
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed
+
+
+def _coerce(hint: Any, value: Any) -> Any:
+    """Coerce a raw API value to the declared field type.
+
+    Raises ValueError/TypeError when the value cannot be coerced, so the
+    caller can fall back to the field default instead of crashing.
+    """
+    if value is None or hint is Any:
+        return value
+
+    origin = get_origin(hint)
+
+    if origin in (list, tuple):
+        args = get_args(hint)
+        inner = args[0] if args else Any
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"expected a list, got {type(value).__name__}")
+        return [_coerce(inner, item) for item in value]
+
+    if origin is dict:
+        args = get_args(hint)
+        inner = args[1] if len(args) == 2 else Any
+        if not isinstance(value, dict):
+            raise TypeError(f"expected a dict, got {type(value).__name__}")
+        return {key: _coerce(inner, item) for key, item in value.items()}
+
+    if origin is Union or isinstance(hint, types.UnionType):
+        for arg in get_args(hint):
+            if arg is type(None):
+                continue
+            try:
+                return _coerce(arg, value)
+            except (ValueError, TypeError, KeyError):
+                continue
+        raise ValueError(f"cannot coerce {value!r} to {hint}")
+
+    if dataclasses.is_dataclass(hint):
+        if not isinstance(value, dict):
+            name = getattr(hint, "__name__", hint)
+            raise TypeError(f"expected a dict for {name}, got {type(value).__name__}")
+        return cast("type[BboxModel]", hint).from_dict(value)
+
+    if hint is bool:
+        return _to_bool(value)
+    if hint is int:
+        return _to_int(value)
+    if hint is float:
+        return _to_float(value)
+    if hint is datetime:
+        return _to_datetime(value)
+    if hint is str:
+        text = value if isinstance(value, str) else str(value)
+        fixed = fix_mojibake(text)
+        return fixed if fixed else None  # the API uses "" for "no value"
+    return value
+
+
+@cache
+def _type_hints(cls: Any) -> dict[str, Any]:
+    return get_type_hints(cls)
+
+
+def _field_default(f: dataclasses.Field[Any]) -> Any:
+    if f.default is not dataclasses.MISSING:
+        return f.default
+    if f.default_factory is not dataclasses.MISSING:
+        return f.default_factory()
+    return None
+
+
+@dataclass
+class BboxModel:
+    """Base model: tolerant ``from_dict`` plus the untouched raw payload."""
+
+    raw: dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        """Build a model from a raw API payload.
+
+        Unknown keys are kept in ``raw``; missing keys keep their default;
+        keys that fail to coerce also fall back to the default.
+        """
+        if not isinstance(data, dict):
+            raise TypeError(f"{cls.__name__}.from_dict expects a dict, got {type(data).__name__}")
+        hints = _type_hints(cast(Any, cls))
+        kwargs: dict[str, Any] = {"raw": dict(data)}
+        for f in dataclasses.fields(cls):
+            if f.name == "raw":
+                continue
+            alias = f.metadata.get("alias")
+            if alias is not None and alias in data:
+                value = data[alias]
+            elif f.name in data:
+                value = data[f.name]
+            else:
+                continue
+            try:
+                kwargs[f.name] = _coerce(hints.get(f.name, Any), value)
+            except (ValueError, TypeError, KeyError, OverflowError, AttributeError):
+                kwargs[f.name] = _field_default(f)
+        return cls(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# /device
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FirmwareVersion(BboxModel):
+    """Firmware version block of the router."""
+
+    version: str | None = None
+    date: datetime | None = None
+
+
+@dataclass
+class ConnectionFlags(BboxModel):
+    """WAN connection types supported by the router ('using' block)."""
+
+    ipv4: bool = False
+    ipv6: bool = False
+    ftth: bool = False
+    adsl: bool = False
+    vdsl: bool = False
+
+
+@dataclass
+class Display(BboxModel):
+    """Front panel display state."""
+
+    luminosity: int = 0
+    luminosity_extender: int = 0
+    state: str | None = None
+    orientation: int | None = None
+
+
+@dataclass
+class DeviceInfo(BboxModel):
+    """Router information, from GET /device."""
+
+    modelname: str | None = None
+    modelclass: str | None = None
+    serialnumber: str | None = None
+    status: int = 0
+    numberofboots: int = 0
+    uptime: int = 0
+    now: datetime | None = None
+    firstusedate: datetime | None = None
+    main: FirmwareVersion | None = None
+    running: FirmwareVersion | None = None
+    reco: FirmwareVersion | None = None
+    spl: FirmwareVersion | None = None
+    tpl: FirmwareVersion | None = None
+    ldr1: FirmwareVersion | None = None
+    ldr2: FirmwareVersion | None = None
+    display: Display | None = None
+    using: ConnectionFlags | None = None
+
+    @property
+    def firmware_version(self) -> str | None:
+        """Return the running firmware version, if known."""
+        if self.running and self.running.version:
+            return self.running.version
+        return self.main.version if self.main else None
+
+
+# ---------------------------------------------------------------------------
+# /hosts
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class IPv6Address(BboxModel):
+    """An IPv6 address of a host."""
+
+    ipaddress: str | None = None
+    status: str | None = None
+    lastseen: datetime | None = None
+    lastscan: datetime | None = None
+
+
+@dataclass
+class EthernetInfo(BboxModel):
+    """Ethernet link details of a host."""
+
+    physicalport: int = 0
+    logicalport: int = 0
+    speed: int = 0  # Mbps
+    mode: str | None = None
+
+
+@dataclass
+class WirelessInfo(BboxModel):
+    """Wi-Fi link details of a host."""
+
+    band: float | None = None
+    rssi_dbm: int | None = field(default=None, metadata={"alias": "rssi0"})
+    rate: int = 0  # Mbps
+    mcs: int = 0
+    tx_usage: int = field(default=0, metadata={"alias": "txUsage"})
+    rx_usage: int = field(default=0, metadata={"alias": "rxUsage"})
+    estimatedRate: int = 0
+
+    @property
+    def rssi(self) -> int | None:
+        """Return the RSSI in dBm."""
+        return self.rssi_dbm
+
+
+@dataclass
+class Host(BboxModel):
+    """A device connected to the Bbox, from GET /hosts (device tracker)."""
+
+    id: int = 0
+    active: bool = False
+    hostname: str | None = None
+    ipaddress: str | None = None
+    macaddress: str | None = None
+    type: str | None = None  # DHCP / Static
+    link: str | None = None  # Ethernet, Wifi 2.4, Wifi 5...
+    lease: int = 0
+    firstseen: datetime | None = None
+    lastseen: int = 0
+    devicetype: str | None = None
+    duid: str | None = None
+    guest: bool = False
+    me: bool = False
+    serial_number: str | None = field(default=None, metadata={"alias": "serialNumber"})
+    ip6address: list[IPv6Address] = field(default_factory=list)
+    ethernet: EthernetInfo | None = None
+    wireless: WirelessInfo | None = None
+
+    @property
+    def is_connected(self) -> bool:
+        """Return True if the host is currently active on the LAN."""
+        return self.active
+
+
+# ---------------------------------------------------------------------------
+# /wan/ip and /wan/ip/stats
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class WANStats(BboxModel):
+    """Traffic counters of one direction (rx or tx) of the WAN interface."""
+
+    packets: int = 0
+    bytes: int = 0
+    packetserrors: int = 0
+    packetsdiscards: int = 0
+    occupation: int = 0  # percent
+    bandwidth: int = 0  # kbit/s currently used
+    max_bandwidth: int = field(default=0, metadata={"alias": "maxBandwidth"})  # kbit/s
+    contractual_bandwidth: int = field(default=0, metadata={"alias": "contractualBandwidth"})
+
+    @property
+    def bandwidth_mbps(self) -> float:
+        """Current bandwidth in Mbit/s."""
+        return self.bandwidth / 1000
+
+    @property
+    def max_bandwidth_mbps(self) -> float:
+        """Maximum bandwidth in Mbit/s."""
+        return self.max_bandwidth / 1000
+
+    @property
+    def contractual_bandwidth_mbps(self) -> float:
+        """Contractual bandwidth in Mbit/s."""
+        return self.contractual_bandwidth / 1000
+
+
+@dataclass
+class WANIPStats(BboxModel):
+    """WAN IP statistics, from GET /wan/ip/stats (bandwidth sensors)."""
+
+    rx: WANStats = field(default_factory=WANStats)
+    tx: WANStats = field(default_factory=WANStats)
+
+
+@dataclass
+class WANIP(BboxModel):
+    """WAN IP configuration, from GET /wan/ip (the ``wan.ip`` block)."""
+
+    ipaddress: str | None = field(default=None, metadata={"alias": "address"})
+    subnet: str | None = None
+    gateway: str | None = None
+    state: str | None = None
+    dnsservers: str | None = None  # comma-separated string on this API
+    dnsserversv6: str | None = None
+    mac: str | None = None
+    mtu: int = 0
+    portrange: str | None = None
+    cgnatenable: bool = False
+    maptenable: bool = False
+    ip6state: str | None = None
+    ip6address: list[IPv6Address] = field(default_factory=list)
+    ip6prefix: list[dict[str, Any]] = field(default_factory=list)
+    # Filled by the client from the sibling blocks wan.link / wan.internet:
+    link_type: str | None = None
+    internet_state: int | None = None
+
+
+# ---------------------------------------------------------------------------
+# /wireless
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class WirelessBand(BboxModel):
+    """One Wi-Fi band SSID configuration (keyed '24', '5', '6', 'guest').
+
+    Warning: ``raw`` contains the ``security`` block, which includes the
+    Wi-Fi passphrase in clear text. Never expose ``raw`` in logs or API
+    responses.
+    """
+
+    id: str | None = None  # SSID name
+    enable: bool = False
+    hidden: bool = False
+    bssid: str | None = None
+
+
+@dataclass
+class WirelessRadio(BboxModel):
+    """One Wi-Fi band radio state (keyed '24', '5', '6', 'guest')."""
+
+    enable: bool = False
+    state: int = 0
+    standard: str | None = None
+    channel: int = 0
+    current_channel: int | None = None
+    current_bandwidth: int | None = None
+
+
+@dataclass
+class Wireless(BboxModel):
+    """Wi-Fi configuration, from GET /wireless (the ``wireless`` block).
+
+    ``bands`` / ``radios`` are keyed by band name as returned by the API
+    ('24', '5', '6', 'guest').
+    """
+
+    status: str | None = None
+    bands: dict[str, WirelessBand] = field(default_factory=dict, metadata={"alias": "ssid"})
+    radios: dict[str, WirelessRadio] = field(default_factory=dict, metadata={"alias": "radio"})
+
+    def band(self, name: str) -> WirelessBand | None:
+        """Return the SSID configuration of one band ('24', '5', '6'...)."""
+        return self.bands.get(name)
+
+    def is_enabled(self, band: str) -> bool | None:
+        """Return whether the radio of one band is enabled, if known."""
+        radio = self.radios.get(band)
+        return radio.enable if radio else None

bbox_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.5
+Name: bbox-api
+Version: 0.1.0
+Summary: Async Python client for the Bouygues Telecom Bbox router API
+Project-URL: Homepage, https://github.com/xavier/bbox-api
+Project-URL: Repository, https://github.com/xavier/bbox-api
+Project-URL: Issues, https://github.com/xavier/bbox-api/issues
+Project-URL: Documentation, https://github.com/xavier/bbox-api#readme
+Author: rettelx
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aiohttp,api,async,bbox,bouygues,bouygues-telecom,gateway,router
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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.11
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: aiohttp<3.14,>=3.9; extra == 'dev'
+Requires-Dist: aioresponses>=0.7; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: aiohttp<3.14,>=3.9; extra == 'test'
+Requires-Dist: aioresponses>=0.7; extra == 'test'
+Requires-Dist: pytest-asyncio>=1; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# bbox-api
+
+Async client for the **Bouygues Telecom Bbox router API** (`/api/v1`), for any
+asyncio app. Python >= 3.11, MIT, single dependency (`aiohttp`), fully typed
+(`py.typed`, mypy-clean) with fault-tolerant dataclass models (unknown or
+malformed payload keys never crash parsing; unknown keys stay in `.raw`).
+
+- **Local**: `BboxClient(pw)` → `http://bbox.lan/api/v1` (also `192.168.1.1` or
+  `mabbox.bytel.fr` with `use_tls=True` — that name resolves only on the LAN,
+  the box hijacks DNS for it). **Remote**: `BboxClient.remote(pw, wan_ip)` →
+  `https://<wan-ip>/api/v1` ("remote access" enabled on the box; the WAN IP is
+  refused from the LAN itself).
+- **Auth is automatic**: admin password → session cookie + cached `btoken`,
+  re-auth on 401, retries on transient errors.
+
+## Install
+
+```bash
+pip install bbox-api
+```
+
+## Usage
+
+```python
+import asyncio
+from bbox_api import BboxClient
+
+
+async def main():
+    async with BboxClient("admin-password") as client:  # local: bbox.lan
+        device = await client.get_device()  # model, firmware, uptime
+        stats = await client.get_wan_ip_stats()  # rx/tx bandwidth_mbps
+        hosts = await client.get_hosts()  # connected devices
+        await client.set_wireless(False)  # all main Wi-Fi bands off
+
+
+asyncio.run(main())
+```
+
+Any endpoint not wrapped by a typed method: `await client.raw_request("alerts")`.
+To share your own `aiohttp.ClientSession`, pass `session=` — the client then
+never closes it.
+
+## Errors
+
+All inherit `BboxApiError`: `BboxInvalidCredentialsError`, `BboxSessionExpiredError`, `BboxRateLimitError`, `BboxNotFoundError`, `BboxConnectionError`, `BboxTimeoutError`.
+
+## Verified endpoints (live-tested on a F@st5688b, fw 25.1.22)
+
+GET endpoints returning HTTP 200, grouped by area:
+
+- **device**: `device`, `device/cpu`, `device/mem`, `device/summary`, `device/log`, `device/led`
+- **hosts**: `hosts`, `hosts/me`, `alerts`
+- **wan**: `wan/ip`, `wan/ip/stats`, `wan/ftth/stats`, `wan/diags`, `cpl`
+- **wireless**: `wireless`, `wireless/24`, `wireless/5`, `wireless/6`, `wireless/guest`,
+  `wireless/24/stats`, `wireless/5/stats`, `wireless/6/stats`, `wireless/wps`,
+  `wireless/repeater`, `wireless/scheduler`
+- **lan / misc**: `summary`, `lan/ip`, `lan/stats`, `iptv`, `services`, `speedtest`,
+  `parentalcontrol`, `voip`, `voip/fullcalllog/<line-id>` (line id from `GET /voip`,
+  e.g. `voip/fullcalllog/1`)
+
+GET endpoints returning 404 on this model/firmware (they raise `BboxNotFoundError`):
+
+- `device/optimization`, `wan/ftth`, `wan/xdsl`, `wan/xdsl/stats`, `wan/cable`
+  (this is a FTTH box), `lan/ip6`, `ddns`, `remote`, `voip/voicemail`,
+  `voip/callforward`, `voip/fullcalllog` without a line id
+
+Writes verified (PUT/POST/DELETE with `btoken`):
+
+- `PUT /wireless` + `radio.enable=0/1` — toggles all main bands (2.4/5/6 GHz) at once
+- `PUT /wireless/guestenable` + `enable=0/1` — guest Wi-Fi
+- `POST` / `DELETE /wireless/wps` — start/stop a WPS session
+
+Behavior notes from live testing:
+
+- `/hosts` returns a **list of blocks**: the first is the main LAN, the following
+  ones are e.g. the guest network (entries flagged `guest=1`, 10.0.0.x subnet).
+  The guest block stays present even when guest Wi-Fi is off (its hosts just show
+  `active=False`). `get_hosts()` parses all blocks and excludes guests unless
+  `include_guests=True`; `get_guests()` returns only guest hosts.
+
+Security warning: `GET /wireless` returns the **Wi-Fi passphrase in clear text**
+(`raw["bands"]["24"]["security"]["passphrase"]`). Never expose a model's `raw`
+dict in logs or API responses.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/Scripts/pip install -e ".[dev]"
+.venv/Scripts/python -m pytest        # 44 tests, mocked API (aiohttp<3.14: aioresponses limit)
+.venv/Scripts/ruff check .
+.venv/Scripts/python -m mypy
+```
+
+CI/CD (`.github/workflows/`): `ci.yml` runs pytest on Python 3.11–3.14 plus
+ruff and mypy on every push/PR; `release.yml` builds the wheel/sdist with
+hatchling and publishes to PyPI on `v*` tags via trusted publishing (OIDC —
+configure the `bbox-api` project on PyPI with this repo as trusted publisher,
+no API token needed).
+
+## License
+
+MIT

bbox_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bbox_api/__init__.py,sha256=dSJuJWPClsL_F1vx5uucgn0lkAsXPYVtXN1kzSP11r0,1161
+bbox_api/client.py,sha256=o6MQXA2stUm3MxfmneBq-E3SP-ydeAr-NuTt7jbtdsY,26897
+bbox_api/const.py,sha256=d5DSex_WmBLrp7gVlnseFX8MXRcAwMy_Vj9LtvMCCt0,1260
+bbox_api/exceptions.py,sha256=2g4CB5LeLIVOza4wylSEuCTk2zONItyLTpbshYlC4xA,2488
+bbox_api/models.py,sha256=M_EJut8uemwpIYwnWEuJnnqqMMQpm77VbgXwiZlMnOk,12891
+bbox_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bbox_api-0.1.0.dist-info/METADATA,sha256=j9lR5SgaPmqkdv7-gG0icXvPvYkHUTJQTA3EWzTd8Zk,5841
+bbox_api-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+bbox_api-0.1.0.dist-info/licenses/LICENSE,sha256=aclySKxemqpUijBxTioUYDHBRtCDs-mmb30bR1sEjZQ,1064
+bbox_api-0.1.0.dist-info/RECORD,,

bbox_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